Seedance · Seedream · Upscaler · Seed Audio · Zhaotutu · Suno · Midjourney
几行代码,生成 AI 视频、图片与音频
本服务提供异步任务接口,用于调用 Seedance 2.0 视频 、视频超分 、
Seedream v5 Pro 图片 、Doubao Seed Audio 音频 、Zhaotutu 扩展 、Suno 音乐 与 Midjourney 模型:
提交任务后轮询结果即可拿到媒体直链,按实际上游消耗计费,失败全额退款。
🎬 视频三种方式
文生视频(t2v)、图生视频(i2v,支持首尾帧)、多模态视频(multi,图片 + 视频 + 音频混合参考)。
⬆️ 视频超分
把已有 MP4 提升到 720p / 1080p / 2k / 4k;模型 zhaotutu-upscaler,按输入时长 × 目标分辨率计费。
🖼️ Seedream 图片
文生图(t2i)与图生图(i2i),支持 1k / 2k 分辨率或自定义宽高,输出 JPEG / PNG。
🔊 Seed Audio
异步音频生成:文本提示词 + 可选音色 / 参考音频 / 参考图;按输出时长计费。
🎵 Suno 音乐
31 个音乐 action:文生曲、续写、翻唱、分轨等;走 /v1/music/*,按上游 cost(USD) 结算。
🎨 Midjourney
Imagine / Upscale / Variation / Video 等;走 /v1/midjourney/*,按上游 cost(USD) 结算。
接口总览
Base URL 统一为 https://api.zhaotutu.ai。
ℹ
站点同时保留旧版端点 POST /v1/video/generations + GET /v1/video/generations/{task_id}(请求体格式相同,查询响应字段不同)。新接入请统一使用 /v1/videos ,旧端点仅为兼容保留。
异步任务实际扣费
所有异步生成任务在完成最终结算后,查询接口都会返回公开的 usage 对象:
终态响应片段 复制
{
"usage": {
"amount": 8.75,
"currency": "CNY"
}
}
✓
amount 必须与本次任务最终实际从用户余额扣除的钱完全一致,单位由 currency 指明;它不是提交任务时的预扣金额。任务失败并已退款时,amount 为 0。
只有任务进入终态并完成多退少补后,usage 才代表最终实扣。
不同查询协议中的位置
查询接口 读取位置
通用图片、视频、音频、3D 任务查询 data.usage
GET /v1/music/tasks/{task_id}data.usage
GET /v1/midjourney/tasks/{task_id}usage
GET /v1/videos/{task_id}usage
GET /v2/query/video_generation/{task_id}task.usage
快速开始
三步跑通第一个视频生成任务。
1
获取 API Key
登录 控制台 → 「API 令牌」→ 新建令牌,得到形如 sk-xxxx 的 API Key。
2
提交任务
以最便宜的 seedance-2.0-mini-t2v(文生视频)为例:
cURL
Python
Node.js
终端 复制
curl -X POST https://api.zhaotutu.ai/v1/videos \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "seedance-2.0-mini-t2v",
"prompt": "a calm lake at sunrise, cinematic light",
"seconds": "5",
"metadata": { "resolution": "480p" }
}'
submit.py 复制
import requests
resp = requests.post(
"https://api.zhaotutu.ai/v1/videos",
headers={"Authorization": "Bearer sk-xxxx"},
json={
"model": "seedance-2.0-mini-t2v",
"prompt": "a calm lake at sunrise, cinematic light",
"seconds": "5",
"metadata": {"resolution": "480p"},
},
)
resp.raise_for_status()
task_id = resp.json()["id"]
print(task_id)
submit.mjs 复制
const resp = await fetch("https://api.zhaotutu.ai/v1/videos", {
method: "POST",
headers: {
Authorization: "Bearer sk-xxxx",
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "seedance-2.0-mini-t2v",
prompt: "a calm lake at sunrise, cinematic light",
seconds: "5",
metadata: { resolution: "480p" },
}),
});
const { id: taskId } = await resp.json();
console.log(taskId);
提交成功立即返回任务 ID,status 初始为 queued:
响应 · 200 复制
{
"id": "task_xxxxxxxxxxxx",
"object": "video",
"model": "seedance-2.0-mini-t2v",
"status": "queued",
"progress": 0,
"created_at": 1783377182
}
⚠
Windows PowerShell 用户 :请把 JSON 写入文件后用 --data-binary "@request.json" 提交。直接在命令行拼接带空格的 JSON 会被拆成多个参数,导致请求失败。
3
轮询任务结果
用任务 ID 每 3~5 秒查询一次,直到 status 变为 completed 或 failed:
cURL
Python
Node.js
终端 复制
curl https://api.zhaotutu.ai/v1/videos/task_xxxxxxxxxxxx \
-H "Authorization: Bearer $SEEDANCE_API_KEY"
poll.py 复制
import time
import requests
headers = {"Authorization": "Bearer sk-xxxx"}
while True:
result = requests.get(
f"https://api.zhaotutu.ai/v1/videos/{task_id}", headers=headers
).json()
if result["status"] in ("completed", "failed"):
break
time.sleep(3)
print(result.get("metadata", {}).get("url") or result.get("error"))
poll.mjs 复制
const headers = { Authorization: "Bearer sk-xxxx" };
let result;
do {
await new Promise((r) => setTimeout(r, 3000));
const resp = await fetch(
`https://api.zhaotutu.ai/v1/videos/${taskId}`, { headers }
);
result = await resp.json();
} while (!["completed", "failed"].includes(result.status));
console.log(result.metadata?.url ?? result.error);
任务成功后 metadata.url 即为视频直链:
响应 · 生成成功 复制
{
"id": "task_xxxxxxxxxxxx",
"object": "video",
"model": "seedance-2.0-mini-t2v",
"status": "completed",
"progress": 100,
"created_at": 1783377182,
"completed_at": 1783377298,
"metadata": { "url": "https://.../output.mp4?X-Tos-Signature=..." }
}
⚠
视频直链是带签名有效期的临时地址 ,请在拿到结果后及时下载转存到自己的存储。
鉴权
所有接口均使用 Bearer Token 鉴权,在请求头中携带控制台创建的 API Key:
HTTP Header 复制
Authorization: Bearer sk-xxxxxxxxxxxx
缺少或格式错误的 Authorization 头会返回 401。API Key 等同于账户余额凭证,请勿写入前端代码或公开仓库。
查询钱包余额
GET
/api/usage/wallet/
用 API Key 查询账户钱包余额(非令牌额度)
返回当前 API Key 所属用户账户 的钱包余额。与 /api/usage/token/(令牌剩余额度)不同:本接口查的是控制台「钱包」里的账户余额。
ℹ
amount 为按站点展示货币换算后的余额(本站通常为人民币);quota / total_available 为内部额度单位。对接业务逻辑时优先使用 amount。
请求
仅需鉴权头,无 Body / Query 参数。
终端 复制
curl https://api.zhaotutu.ai/api/usage/wallet/ \
-H "Authorization: Bearer $SEEDANCE_API_KEY"
响应字段
data
amountnumber
钱包剩余余额(按 display_type 换算后的展示值)。
used_amountnumber
累计已用量(展示值)。
quotainteger
钱包剩余额度(内部单位),与 total_available 相同。
used_quotainteger
累计已用额度(内部单位)。
display_typestring
展示类型,如 CNY / USD / TOKENS。
响应 · 200 复制
{
"code": true,
"message": "ok",
"data": {
"object": "wallet_balance",
"quota": 1500000,
"used_quota": 250000,
"total_available": 1500000,
"amount": 3.0,
"used_amount": 0.5,
"display_type": "CNY",
"username": "demo",
"group": "default"
}
}
MiniMax-H3 · MiniMax V2 格式
MiniMax-H3 支持文生视频、首帧/尾帧/首尾帧、多模态参考视频与独立驱动音频,使用本站 API Key。MiniMax V2 客户端替换 Base URL 为 https://api.zhaotutu.ai,并按本节支持范围调整参数。
完整调用指南与 Python 示例 · 下载 OpenAPI JSON
ℹ 本服务通过 RunningHub 生成视频,480P、drive_audio、audio_control 和最长 60 秒驱动音频属于扩展。当前不提供官方 2K、Context-IR 或再生成能力。参考站的 target / conditions / OSS PUT SPI 不能作为本接口请求体。
方法 路径 响应
POST /v2/video_generation{"task_id":"..."}
GET /v2/query/video_generation/{task_id}{"task":{...}}
GET /v2/query/video_generation{"items":[...],"total":1}
DELETE /v2/video_generation/{task_id}删除终态记录;取消必须得到上游确认
价格与参数
分辨率 元/秒 5 秒 10 秒 15 秒
480P 0.15 0.75 1.50 2.25
768P 0.30 1.50 3.00 4.50
按请求输出秒数计算标准零售价,参考媒体不另收费。普通任务整数 4–15 秒;有独立驱动音频时整数 4–60 秒。账户实际价格以适用分组和折扣为准。
字段 要求
model必填,精确名称 MiniMax-H3
content必填,至少一个非空 text,拼接后最多 10000 字符;最多 9 参考图、3 参考音频、3 视频和额外 1 条驱动音频;也可用独立首尾帧模式
resolution必填,480P / 768P,也接受小写
duration必填整数秒数,普通 4–15;有 drive_audio 时 4–60
ratio1:1 / 2:3 / 3:2 / 3:4 / 4:3 / 9:16 / 16:9 / 21:9。纯文本必填;参考省略时 16:9;首/尾帧可用 adaptive / auto 选择最近固定比例
audio_controlmode=native/lock_source/remix_source/reference_only;denoise_strength 0–1;add_drive_as_reference 布尔。非 native 模式要求驱动音频
callback_url可选 HTTPS 地址,仅 443 端口;先验证 challenge,再通知终态
文生视频
cURL 复制
curl https://api.zhaotutu.ai/v2/video_generation \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "MiniMax-H3",
"content": [{"type":"text","text":"航拍晨光中的山谷,镜头平稳前进。"}],
"resolution": "480P",
"duration": 5,
"ratio": "16:9"
}'
HTTP 200 返回 task_id 后,使用同一个 Key 查询 GET /v2/query/video_generation/{task_id}。成功读取 task.content.url,无需旧版 file_id 检索。状态为 queued、running、succeeded、failed、cancelled。
首帧、尾帧与首尾帧
JSON 复制
{
"model":"MiniMax-H3",
"content":[
{"type":"text","text":"人物自然转身,平稳过渡到尾帧构图。"},
{"type":"image_url","image_url":{"url":"https://example.com/start.jpg"},"role":"first_frame"},
{"type":"image_url","image_url":{"url":"https://example.com/end.jpg"},"role":"last_frame"}
],
"resolution":"768P", "duration":5, "ratio":"adaptive"
}
省略尾帧项即可首帧生成,省略首帧项即可尾帧生成;图片省略 role 时也视为首帧。首尾帧还可与参考图片、音频、视频或驱动音频混用,各类上限独立计数,这是本服务扩展。自适应按首帧(仅有尾帧时按尾帧)选择最接近的 RH 固定比例,不保证任意原图比例的精确输出。
参考图片、视频、声音与驱动音频
JSON 复制
{
"model": "MiniMax-H3",
"content": [
{"type":"text","text":"参考图中的人物面对镜头,口型跟随驱动音频,说出明文台词。"},
{"type":"image_url","image_url":{"url":"https://example.com/person.jpg"},"role":"reference_image"},
{"type":"audio_url","audio_url":{"url":"https://example.com/dialogue.wav"},"role":"drive_audio"}
],
"resolution": "768P", "duration": 5, "ratio": "16:9",
"audio_control": {"mode":"lock_source","denoise_strength":0,"add_drive_as_reference":true}
}
参考视频使用 type=video_url、video_url.url、role=reference_video;可在内容项顶层加 start_time_seconds,按 24 FPS 换算起始帧。参考声音使用 type=audio_url、audio_url.url、role=reference_audio,与独立 drive_audio 分开计数。每条参考视频(包括偏移后的素材)需为 2–15 秒。媒体可先调用本站 素材上传接口 取得 URL。
有驱动音频时默认 lock_source + denoise_strength=0 + add_drive_as_reference=true;无驱动时默认 native + 0.35 + false。remix_source 可调去噪 0–1;需要独立参考音色时可把驱动作为参考设为 false。reference_only 必须有驱动,驱动作为参考省略时为 true,显式 false 报错。native 也可附带驱动,是否作为参考由该布尔参数决定。显式 0 和 false 均会保留。
ℹ seed、采样步数与 flow shift 不对外开放。参考场景默认 16:9,显式 adaptive / auto 会报错;关键帧提供最近固定比例的自适应,也执行用户指定的固定比例,这些行为与官方有差异。480P、2:3/3:2、关键帧与参考素材混合、驱动控制和视频起始偏移是本服务扩展。当前 RH 路径不提供官方格式媒体用量,任务响应省略 usage;输出按 17n+5 帧对齐可能略长,仍按请求秒数计费。
任务管理、回调与错误
列表查询最近 7 天,支持 page_num(默认 1,最多 10000)、page_size(默认 10,最多 100)及 filter.status、重复的 filter.task_ids(最多 100 个)、filter.model、filter.task_type=generation。成功/失败记录可删除,也允许删除已取消记录(扩展),不会重复退款。RH 无法确认排队取消时返回错误,原任务继续,不会提前退款。
回调先 POST {"challenge":"..."},3 秒内以 HTTP 200 返回相同 JSON challenge 或纯文本。终态通知使用查询响应格式,收到任意 2xx 即视为送达,最多尝试 5 次,失败后等待 1/2/4/8 分钟。请按任务 ID 和状态幂等消费。中间状态推送不作保证。
错误示例 复制
{"type":"error","error":{"type":"bad_request_error","message":"invalid request parameters","http_code":"400"},"request_id":"..."}
HTTP 错误与 HTTP 200 内的 task.error 不同。建议每 5–10 秒轮询;创建超时不代表未创建,不要无条件重发付费任务。提交结果不确定的错误响应如带 X-Task-Id,请保存它并查询已有任务;此时保留预扣,后台尝试从 bridge 恢复,不保证上游 ID 已丢失的任务可找回。完整示例、素材上传、错误处理与官方参考链接见 完整指南 。
主、备用凭据按固定顺序调用;仅在未取得任务编号且上游明确拒绝(HTTP 401/402/403/429 或非零业务错误码)时切换一次。已受理任务及超时、5xx、无效 JSON 不自动重建;两次均被拒绝时保留最后错误,仅容量限制归为 429。
提交视频任务
POST
/v1/videos
创建异步视频生成任务,立即返回任务 ID
请求体
Body 参数 · application/json
modelstring 必填
模型名,如
seedance-2.0-mini-t2v,完整列表见
模型列表 。模型名后缀决定任务类型:
-t2v 文生视频 /
-i2v 图生视频 /
-multi 多模态视频。
promptstring t2v / multi 必填
文本提示词,最长 20480 字符;-i2v 模型可选。多模态场景可用 @Image 1、@Video 1 指代第几个参考素材,例如「把 @Video 1 中的人物替换成 @Image 1 中的人物」。
imagesstring[] i2v 必填
参考图片 URL 数组,仅 -i2v 模型使用。传 1 张为首帧图;传 2 张时第 2 张作为尾帧图。也可用单数字段 image(单个 URL 字符串)代替。JPG / JPEG / PNG / WEBP,单张 ≤ 30MB。
secondsstring 可选
视频时长(秒)。可选 "4" ~ "15" 的整数,或 "-1" 让模型智能选择时长。默认 "5"。
metadataobject 可选
生成参数集合,所有字段均可选:
resolutionstring
输出分辨率。Standard 档可选
480p /
720p /
1080p /
2k /
4k /
native1080p /
native4k;Fast、Mini 档可选
480p /
720p /
1080p /
2k /
4k。
默认 720p。 注意
1080p /
2k /
4k 为超分档,另收附加费,见
价格 。
ratiostring
画面比例,可选 16:9 / 4:3 / 1:1 / 3:4 / 9:16 / 21:9。默认 adaptive(自适应)。
seedinteger
随机种子,取值 -1 ~ 2147483647。默认 -1(随机)。
generate_audioboolean
是否生成配音 / 音效。默认 true。
return_last_frameboolean
是否额外返回视频最后一帧图片。默认 false。
contentarray
仅 -multi 模型使用 ,传入图片 / 视频 / 音频参考素材数组,结构见下方「多模态素材」。
各任务类型的用法与素材限制
任务类型 传参方式 素材限制
-t2v 文生视频
只传 prompt
无素材
-i2v 图生视频
prompt(可选)+ 顶层 images
图片 1~2 张:第 1 张为首帧(必填),第 2 张为尾帧(可选)。JPG / JPEG / PNG / WEBP,单张 ≤ 30MB
-multi 多模态视频
prompt(必填)+ metadata.content
图片 ≤ 9 张(JPG / JPEG / PNG / WEBP,单张 ≤ 30MB);视频 ≤ 3 个(MP4,单个 ≤ 50MB);音频 ≤ 3 个(MP3 / WAV,单个 ≤ 50MB,国内版 Fast 档 ≤ 15MB)。三类可混合,至少提供 1 个参考素材
多模态素材(metadata.content)
数组中每个元素按 type 区分三种素材:
image_url参考图片
{ "type": "image_url", "image_url": { "url": "https://..." } }
video_url参考视频
{ "type": "video_url", "video_url": { "url": "https://..." } } —— 传入参考视频后,整个任务按「有参考视频」的
更低 Token 单价档 计费,见
价格 。
audio_url参考音频
{ "type": "audio_url", "audio_url": { "url": "https://..." } }
⚠
一旦传了 metadata.content,它会整体覆盖 顶层 images 的效果。多模态场景请把图片也一并写进 content 数组,不要再单独传顶层 images。
多模态完整示例(1 张图 + 1 个视频,把视频中的人物换成图片中的人物):
请求体 · seedance-2.0-standard-multi 复制
{
"model": "seedance-2.0-standard-multi",
"prompt": "把 @Video 1 中的人物替换成 @Image 1 中的人物",
"seconds": "5",
"metadata": {
"resolution": "1080p",
"content": [
{ "type": "image_url", "image_url": { "url": "https://your-cdn.example.com/person.png" } },
{ "type": "video_url", "video_url": { "url": "https://your-cdn.example.com/source.mp4" } }
]
}
}
响应
提交成功返回 200,任务进入队列:
响应 · 200 复制
{
"id": "task_xxxxxxxxxxxx",
"object": "video",
"model": "seedance-2.0-mini-t2v",
"status": "queued",
"progress": 0,
"created_at": 1783377182
}
查询任务结果
GET
/v1/videos/{task_id}
查询任务状态、进度与生成结果
路径参数 task_id 为提交任务时返回的 id。建议每 3~5 秒轮询一次。
任务状态
status 含义
queued 排队中,尚未开始处理
in_progress 生成中,progress 为 0~100 的进度百分比
completed 生成成功,metadata.url 为视频直链
failed 生成失败,详见 error.code / error.message,费用全额退还
响应示例
生成中
生成成功
生成失败
响应 · in_progress 复制
{
"id": "task_xxxxxxxxxxxx",
"object": "video",
"model": "seedance-2.0-mini-t2v",
"status": "in_progress",
"progress": 50,
"created_at": 1783377182,
"metadata": { "url": "" }
}
响应 · completed 复制
{
"id": "task_xxxxxxxxxxxx",
"object": "video",
"model": "seedance-2.0-mini-t2v",
"status": "completed",
"progress": 100,
"created_at": 1783377182,
"completed_at": 1783377298,
"metadata": { "url": "https://.../output.mp4?X-Tos-Signature=..." }
}
响应 · failed 复制
{
"id": "task_xxxxxxxxxxxx",
"object": "video",
"model": "seedance-2.0-mini-t2v",
"status": "failed",
"progress": 100,
"error": {
"code": "video_generation_failed",
"message": "..."
}
}
提交图片任务
POST
/v1/image/generations
提交 Seedream v5 Pro 异步图片生成或图层拆分任务
与视频接口一样采用「提交 → 轮询」异步模式。当前支持文生图(t2i)、图生图(i2i)与图层拆分。
请求体字段
Body · application/json
modelstring 必填
Seedream:seedream-v5-pro-t2i / seedream-v5-pro-i2i / seedream-v5-pro-layer-decomposition、dola-seedream-5.0-pro-*;千问:qwen-image-3.0-* / qwen-image-3.0-pro-* / qwen-image-3.0-global-*;Zhaotutu Image G-2:zhaotutu-image-g2-t2i / zhaotutu-image-g2-i2i(resolution 仅 1k);Zhaotutu 扩展:zhaotutu-image-g-v2-lowprice / zhaotutu-image-gk-v15 / zhaotutu-image-gk-v15-edit / zhaotutu-image-gk-v2 / zhaotutu-image-gk-v2-edit / zhaotutu-image-nb-*。
promptstring 视模型
普通 Seedream 必填,长度 5 ~ 2000 字符;图层拆分可选,省略时自动识别主要元素。
imagesstring[] i2i / 图层拆分必填
普通图生图最多
10 张,单张 ≤10MB;图层拆分必须恰好 1 张,≤30MB。也可用单数字段
image。可用
上传接口 换取直链。
metadataobject 可选
图片参数集合,见下表。
metadata 字段
metadata
resolutionstring 可选
普通 Seedream:1k / 2k,优先级高于 width × height ;图层拆分:auto / 1k / 1.5k / 2k。Zhaotutu Image G-2:仅 1k 。zhaotutu-image-g-v2-lowprice:1k / 2k / 4k(zhaotutu-image-gk-* 无此字段)。
widthinteger 可选
输出宽度,范围 240 ~ 8192。未传 resolution 时生效。
heightinteger 可选
输出高度,范围 240 ~ 8192。未传 resolution 时生效。
output_formatstring 可选
输出格式:jpeg / png。
文生图 · seedream-v5-pro-t2i 复制
curl -X POST https://api.zhaotutu.ai/v1/image/generations \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-H "Content-Type: application/json" \
--data-binary @- <<'EOF'
{
"model": "seedream-v5-pro-t2i",
"prompt": "高端护肤品电商主图,纯白柔光展台,玻璃精华瓶",
"metadata": {
"resolution": "2k",
"output_format": "jpeg"
}
}
EOF
图生图 · seedream-v5-pro-i2i 复制
{
"model": "seedream-v5-pro-i2i",
"prompt": "横版复古馆藏风美妆宣传海报,藏青深蓝色哑光底",
"images": ["https://your-cdn.example.com/ref.png"],
"metadata": {
"resolution": "1k",
"output_format": "jpeg"
}
}
图层拆分 · seedream-v5-pro-layer-decomposition 复制
{
"model": "seedream-v5-pro-layer-decomposition",
"images": ["https://your-cdn.example.com/source.png"],
"metadata": {
"resolution": "auto",
"output_format": "jpeg"
}
}
提交响应
响应 · 200 复制
{
"id": "task_xxxxxxxxxxxx",
"task_id": "task_xxxxxxxxxxxx",
"status": "queued",
"model": "seedream-v5-pro-t2i",
"created_at": 1783717700
}
查询图片任务
GET
/v1/image/generations/{task_id}
查询图片任务状态与结果
建议每 3~5 秒轮询一次,直到 data.status 为 SUCCESS 或 FAILURE。成功时 data.result_url 是主图;图层拆分的全部底图/图层 URL 位于 data.data.content.image_urls(约 24 小时有效,请及时下载转存)。
ℹ
图片查询接口返回通用任务记录结构(与视频的 OpenAI Video 风格响应不同)。请按下方字段读取。
status 取值(data.status)
status 含义
NOT_START / SUBMITTED已提交,排队中
IN_PROGRESS生成中
SUCCESS成功,result_url 为图片直链
FAILURE失败,见 fail_reason,费用全额退还
终端 复制
curl https://api.zhaotutu.ai/v1/image/generations/task_xxxxxxxxxxxx \
-H "Authorization: Bearer $SEEDANCE_API_KEY"
响应 · SUCCESS(节选) 复制
{
"code": "success",
"data": {
"task_id": "task_xxxxxxxxxxxx",
"status": "SUCCESS",
"progress": "100%",
"result_url": "https://.../base.jpg",
"quota": 270000,
"data": {
"status": "succeeded",
"content": {
"image_url": "https://.../base.jpg",
"image_urls": ["https://.../base.jpg", "https://.../layer-1.png"]
}
}
}
}
混元 3D v3.1
POST /v1/3d/generations 提交文生 / 图生 3D 任务
GET /v1/3d/generations/{task_id} 查询 3D 任务
模型:hunyuan3d-v3.1-text-to-3d(必填 prompt)或 hunyuan3d-v3.1-image-to-3d(images 1–8 张 JPG/PNG,顺序为正、左、右、后、上、下、左前、右前视图)。
可选参数:face_count 10000–1500000(默认 500000)、enable_pbr(默认 false)、generate_type(Normal / Geometry / Sketch)。成功后 data.result_url 与 data.data.content.file_url 返回 GLB 文件 URL,约 24 小时过期。
文生 3D 复制
curl -X POST https://api.zhaotutu.ai/v1/3d/generations \
-H "Authorization: Bearer <API Key>" \
-H "Content-Type: application/json" \
--data-binary '{"model":"hunyuan3d-v3.1-text-to-3d","prompt":"一只青花陶瓷茶壶","face_count":500000,"enable_pbr":false,"generate_type":"Normal"}'
提交音频任务
POST
/v1/audio/generations
提交 Doubao Seed Audio 异步音频生成任务
与图片接口一样采用「提交 → 轮询」异步模式。当前模型包含 Seed Audio、Mureka BGM/歌曲、MiniMax Speech 2.8/Voice Clone/Music 2.6 与 Qwen3 TTS。
ℹ Mureka 伴奏模型要求 prompt 与 metadata.instrumental_id 二选一;metadata.n 为 1–3(默认 2,¥0.34/条),metadata.stream 默认 false。多结果时 result_url 为第一条,完整有序列表位于 data.content.audio_urls。
ℹ
本接口与 OpenAI 风格的同步 TTS POST /v1/audio/speech 不是同一条路径 。Seed Audio 请使用 /v1/audio/generations。
请求体字段
Body · application/json
modelstring 必填
doubao-seed-audio-1.0。
promptstring 必填
音频生成提示词,长度 5 ~ 2048 字符(映射为上游 text_prompt)。
imagesstring[] 可选
参考图片 URL(取首张 → 上游 image_url)。不可 与 metadata.speaker 或参考音频同时使用。
metadataobject 可选
音色、格式、语速等参数,见下表。
metadata 字段
metadata
speakerstring 可选
音色 ID(豆包语音合成 2.0 / 声音复刻)。与参考音频、images 互斥。
audio_urlstring | string[] 可选
参考音频 URL,最多 3 个(MP3 / WAV,单文件 ≤10MB)。也可用 audio_urls。与 speaker、images 互斥。
formatstring 可选
输出格式,默认 wav。可选 wav / mp3 / pcm / ogg_opus。
sample_ratestring 可选
采样率(Hz),默认 24000。可选 8000 / 16000 / 24000 / 32000 / 44100。
speech_rateinteger 可选
语速,范围 -50 ~ 100(100=2.0×,-50=0.5×)。未传时服务端默认 0。
loudness_rateinteger 可选
音量,范围 -50 ~ 100。未传默认 0。
pitch_rateinteger 可选
音调,范围 -12 ~ 12。未传默认 0。
音色生成 · doubao-seed-audio-1.0 复制
curl -X POST https://api.zhaotutu.ai/v1/audio/generations \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-H "Content-Type: application/json" \
--data-binary @- <<'EOF'
{
"model": "doubao-seed-audio-1.0",
"prompt": "gentle rain falling on a quiet city street at night, soft ambient atmosphere",
"metadata": {
"speaker": "zh_male_shaonianzixin_uranus_bigtts",
"format": "mp3",
"sample_rate": "24000"
}
}
EOF
提交响应
响应 · 200 复制
{
"id": "task_xxxxxxxxxxxx",
"task_id": "task_xxxxxxxxxxxx",
"status": "queued",
"model": "doubao-seed-audio-1.0",
"created_at": 1783870738
}
查询音频任务
GET
/v1/audio/generations/{task_id}
查询音频任务状态与结果
建议每 3~5 秒轮询一次,直到 data.status 为 SUCCESS 或 FAILURE。成功时从 data.result_url 取音频直链(约 24 小时有效,请及时下载转存)。
ℹ
音频查询接口返回通用任务记录结构(与图片查询相同,与视频的 OpenAI Video 风格响应不同)。
status 取值(data.status)
status 含义
NOT_START / SUBMITTED已提交,排队中
IN_PROGRESS生成中
SUCCESS成功,result_url 为音频直链
FAILURE失败,见 fail_reason,费用全额退还
终端 复制
curl https://api.zhaotutu.ai/v1/audio/generations/task_xxxxxxxxxxxx \
-H "Authorization: Bearer $SEEDANCE_API_KEY"
响应 · SUCCESS(节选) 复制
{
"code": "success",
"data": {
"task_id": "task_xxxxxxxxxxxx",
"status": "SUCCESS",
"progress": "100%",
"result_url": "https://.../output.mp3",
"quota": 42000,
"data": {
"status": "succeeded",
"content": {
"audio_url": "https://.../output.mp3"
}
}
}
}
文本对话(同步)
POST
/v1/chat/completions
OpenAI Chat Completions 兼容对话,同步/流式返回
模型:deepseek/deepseek-v4-flash-vision-exp、glm/glm-5.3-flash、glm-5.3、qwen/qwen3.8-flash-next、qwen/qwen3.8-max(Qwen 3.8 Max)、zhaotutu/gk-4.6(GK 4.6 海外版)、zhaotutu/g6-astra(GPT-6 Astra 节省版)、zhaotutu/g5.6-sol、zhaotutu/g5.6-terra、zhaotutu/g5.6-luna、zhaotutu/g5.5、zhaotutu/gm-3.8-flash 与 kimi-k3(Kimi K3)。兼容 OpenAI Chat Completions 格式;支持 stream=true 流式输出。与异步图/视频任务接口不是同一路径。
DeepSeek Vision 实验版为 1,048,576 tokens 上下文;RH 目录声明支持图片输入、工具调用、流式输出和结构化输出。上游目录价为输入 ¥3、输出 ¥9、缓存命中 ¥0.1 每 1M tokens;实验版能力和价格可能调整。
RH 国内新模型:两个 Flash 模型为 262,144 tokens 上下文,GLM-5.3 为 1,048,576 tokens。GLM-5.3 为纯文本输入、始终开启推理,工具选择仅支持 auto,不支持结构化输出;两个 Flash 模型的 RH 目录声明支持视觉和结构化输出。本次实测范围为普通及流式文本对话。按上游人民币实扣账单与站点成本比例结算,价格以控制台为准。
ℹ
按 Token 用量结算(输入 / 输出倍率见定价页)。这些模型默认启用推理;回复中可能包含 reasoning_content,最终回答在 content。建议为短测试设置足够的 max_tokens(如 ≥256)。
ℹ
zhaotutu/gk-4.6 支持 500K 上下文、视觉输入、工具调用与推理。输入上下文少于 200K tokens 时,输入 / 输出 / 缓存读取分别为 ¥14 / ¥42 / ¥3.5 每 1M tokens;达到 200K 后分别为 ¥28 / ¥84 / ¥7。最终按海外上游返回的实际账单换算结算。
ℹ
zhaotutu/g6-astra 支持 1,050,000 tokens 上下文、视觉输入、工具调用、推理与流式输出。输入上下文不超过 272K tokens 时,输入 / 输出 / 缓存读取 / 缓存写入分别为 ¥28.82 / ¥144.12 / ¥2.88 / ¥36.03 每 1M tokens;超过 272K 后分别为 ¥57.65 / ¥216.18 / ¥5.76 / ¥72.06。最终按海外上游返回的实际美元账单换算结算。
GPT 节省版 zhaotutu/g5.6-sol、zhaotutu/g5.6-terra、zhaotutu/g5.6-luna、zhaotutu/g5.5 支持文本与图片输入、工具调用、推理和流式输出,上下文最长 1,050,000 tokens。以下为人民币每 1M tokens 参考价,档位由完整输入上下文长度决定;最终按上游实际美元账单换算结算,具体以控制台定价为准。
模型 ≤272K:输入 / 输出 / 缓存读 / 缓存写 >272K:输入 / 输出 / 缓存读 / 缓存写
zhaotutu/g5.6-sol¥14.4118 / ¥86.4706 / ¥1.4412 / ¥18.0147 ¥28.8235 / ¥129.7059 / ¥2.8824 / ¥36.0294
zhaotutu/g5.6-terra¥5.7647 / ¥34.5882 / ¥0.5765 / ¥7.2059 ¥11.5294 / ¥51.8824 / ¥1.1529 / ¥14.4118
zhaotutu/g5.6-luna¥0.5765 / ¥3.4588 / ¥0.0576 / ¥0.7206 ¥1.1529 / ¥5.1882 / ¥0.1153 / ¥1.4412
zhaotutu/g5.5¥14.4118 / ¥86.4706 / ¥1.4412 / ¥18.0147 ¥28.8235 / ¥129.7059 / ¥2.8824 / ¥36.0294
GM 3.8 Flash
zhaotutu/gm-3.8-flash 支持文本与图片输入、工具调用、推理和流式输出,上下文上限为 1,048,576 tokens。输入 / 输出 / 缓存命中参考价分别为 ¥3.0882 / ¥15.4412 / ¥0.308824 每 1M tokens,按全上下文统一单价计费。最终按上游实际美元账单换算结算,具体以控制台为准。
请求
JSON Body
modelstring 必填
deepseek/deepseek-v4-flash-vision-exp、glm/glm-5.3-flash、glm-5.3、qwen/qwen3.8-flash-next、qwen/qwen3.8-max、zhaotutu/gk-4.6、zhaotutu/g6-astra、zhaotutu/g5.6-sol、zhaotutu/g5.6-terra、zhaotutu/g5.6-luna、zhaotutu/g5.5、zhaotutu/gm-3.8-flash 或 kimi-k3。模型名中的斜杠必须保留。
messagesarray 必填
对话消息列表;每项含 role(system / user / assistant)与 content。
streamboolean 可选
true 流式(SSE);false 一次性返回。建议显式传值。
max_tokensinteger 可选
最大生成 token 数(含推理消耗)。
temperaturenumber 可选
采样温度,范围约 0–2。
终端 复制
curl -X POST https://api.zhaotutu.ai/v1/chat/completions \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen/qwen3.8-max",
"stream": false,
"max_tokens": 256,
"messages": [
{"role": "user", "content": "用一句话介绍你自己"}
]
}'
响应 · json 复制
{
"id": "chatcmpl-...",
"object": "chat.completion",
"model": "kimi-k3",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "...",
"reasoning_content": "..."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 20,
"completion_tokens": 80,
"total_tokens": 100
}
}
语音转写(同步)
POST
/v1/audio/transcriptions
OpenAI Whisper 兼容语音转写,同步返回文本
模型:whisper-1。使用 multipart/form-data 上传音频,同步 返回转写结果(无需轮询)。与异步 Seed Audio /v1/audio/generations 不是同一路径。
ℹ
计费按音频时长:1 分钟 = 1000 tokens 。支持 mp3 / wav / flac / m4a / mp4 / ogg / opus / aac / aiff;当前不支持 webm 。
请求
Form 参数 · multipart/form-data
response_formatstring 可选
json(默认)/ verbose_json / srt / text / vtt。
终端 复制
curl -X POST https://api.zhaotutu.ai/v1/audio/transcriptions \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-F "file=@/path/to/audio.mp3" \
-F "model=whisper-1" \
-F "response_format=json"
响应 · json 复制
{
"text": "Hello world",
"usage": { "type": "duration", "seconds": 10 }
}
提交音乐任务(Suno)
POST
/v1/music/generations[/:action]
提交 Suno 音乐生成 / 二次处理任务(异步)
⚠
与 Seed Audio / Whisper 不是同一路径。
Seed Audio 用 /v1/audio/generations;语音转写用 /v1/audio/transcriptions;
Suno 必须用 /v1/music/*。
ℹ
计费 SKU 由路径 决定(如 suno-generation、suno-extend),
不是 请求体里的 model(上游固定为 suno)。
完整 action 表见 Suno 分类 。
路径
路径 计费 SKU 说明
POST /v1/music/generationssuno-generation文生曲(灵感 / 自定义歌词)
POST /v1/music/generations/{action}suno-{action}action 为 kebab-case,见模型表
常用请求字段(generation)
JSON Body
versionstring 必填
v3.5 / v4 / v4.5 / v4.5+ / v4.5-all / v5 / v5.5。影响音质与计费。
promptstring 必填
灵感文案(custom=false)或歌词(custom=true)。
customboolean 可选
false(默认)灵感模式;true 自定义歌词模式。
instrumentalboolean 可选
true = 纯伴奏(无人声)。
title / style / vocal_genderstring 可选
曲名、风格标签(字段名是 style 不是 tags)、人声偏好 Male/Female。
modelstring 可选
可写 suno;网关路由不依赖此字段。
二次处理常见字段
task_id + 可选 audio_index(1-based,默认 1):引用本站先前音乐任务的某一轨
task_ids(恰好 2 个):仅 mashup
audioFilePath / audio_url / audio_urls:公网音频 URL(upload / create-voice / inspo)
时间类:continue_at、start_s、end_s、duration_s、speed 等按 action 必填
本地校验失败(缺必填)返回 400,零扣费 。
文生曲 · generation 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "suno",
"custom": false,
"version": "v5",
"prompt": "lo-fi piano with soft rain ambience",
"instrumental": true
}'
续写 · extend 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/extend \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "suno",
"task_id": "task_xxxxxxxxxxxx",
"audio_index": 1,
"continue_at": 30,
"version": "v5.5"
}'
响应
响应 · 200 复制
{
"code": 200,
"data": [
{ "status": "submitted", "task_id": "task_xxxxxxxxxxxx" }
]
}
记下 data[0].task_id,用下方查询接口轮询。个别 action(如 upsample-tags)可能同步返回结果,仍可用同一查询接口。
查询音乐任务(Suno)
GET
/v1/music/tasks/{task_id}
查询 Suno 任务状态与结果(透传上游形状,保留 music[])
建议每 3~5 秒轮询,直到 data.status 为 completed / failed(或等价终态)。成功时从 data.result.music[] 取音轨(常见 2 首)。
终端 复制
curl https://api.zhaotutu.ai/v1/music/tasks/task_xxxxxxxxxxxx \
-H "Authorization: Bearer $SEEDANCE_API_KEY"
响应 · completed(节选) 复制
{
"code": 200,
"data": {
"id": "task_xxxxxxxxxxxx",
"task_id": "task_xxxxxxxxxxxx",
"status": "completed",
"progress": 100,
"cost": 0.05,
"result": {
"music": [
{
"audio_id": "...",
"audio_url": "https://.../track-a.mp3",
"image_url": "https://.../cover.jpg",
"title": "Probe Loop",
"lyrics": "[Instrumental]",
"duration": 103.56,
"status": "complete"
},
{
"audio_id": "...",
"audio_url": "https://.../track-b.mp3",
"duration": 86,
"status": "complete"
}
]
}
}
}
⚠
结果直链可能较短有效期,请尽快下载转存。二次处理请用本站返回的公开 task_* id(网关会映射到上游)。
提交 Midjourney 任务
POST
/v1/midjourney/generations[/:action]
提交 Midjourney 文生图 / 二次操作 / 图生视频(异步)
⚠
与历史 /mj/* Discord 代理协议不是同一套 。
本站接口:/v1/midjourney/*。计费 SKU 由路径决定(如 midjourney-imagine),
body.model 固定/可写 midjourney,不参与路由。完整 action 见 Midjourney 。
路径
路径 计费 SKU 说明
POST /v1/midjourney/generationsmidjourney-imagine文生图 / 垫图(默认入口)
POST …/generations/imaginemidjourney-imagine显式 Imagine,与上等价
POST …/generations/{action}midjourney-{action}kebab-case action
Imagine 常用字段
JSON Body
promptstring 必填
提示词;可含原生 MJ 参数(如 --ar 16:9 --v 6.1)。
speedstring 可选
relax(默认)/ fast / turbo。
size / version / image_urlsmixed 可选
宽高比、版本、垫图 URL;也可写在 prompt 的 -- 参数里(body 优先)。
二次操作
多数接口需要本站公开 task_id(网关映射上游);选图类另需 index(1–4)或 custom_id(来自查询返回的 buttons[].customId)。
Imagine · relax 复制
curl -X POST https://api.zhaotutu.ai/v1/midjourney/generations \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "a small red apple on a white table, simple studio photo",
"size": "1:1",
"version": "6.1",
"speed": "relax"
}'
Upscale · U1 复制
curl -X POST https://api.zhaotutu.ai/v1/midjourney/generations/upscale \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-H "Content-Type: application/json" \
-d '{"task_id":"task_xxxxxxxxxxxx","index":1}'
响应
响应 · 200 复制
{
"code": 200,
"data": [
{ "status": "submitted", "task_id": "task_xxxxxxxxxxxx" }
]
}
查询 Midjourney 任务
GET
/v1/midjourney/tasks/{task_id}
查询状态与结果(MJ 风格:四宫格 / 单图 / buttons)
建议 3~5 秒轮询,直到 status 为 SUCCESS / FAILURE(或 MODAL 需再调 /modal)。
成功时读 image_urls(4 张)与 grid_image_url;二次操作用 buttons[].customId 或 index。
终端 复制
curl https://api.zhaotutu.ai/v1/midjourney/tasks/task_xxxxxxxxxxxx \
-H "Authorization: Bearer $SEEDANCE_API_KEY"
响应 · SUCCESS(节选) 复制
{
{
"id": "task_xxxxxxxxxxxx",
"status": "SUCCESS",
"progress": "100%",
"cost": 0.04504,
"grid_image_url": "https://.../grid.png",
"image_urls": ["https://.../0.png", "https://.../1.png", "https://.../2.png", "https://.../3.png"],
"buttons": [
{ "customId": "MJ::JOB::upsample::1::...", "label": "U1" },
{ "customId": "MJ::JOB::variation::1::...", "label": "V1" }
]
}
上传参考素材
POST
/v1/files/upload
上传本地文件,换取 24 小时有效的公网直链
没有自己的对象存储 / 图床时,用这个接口把本地素材换成可填入请求体的 URL。上传本身免费 。
请求
Form 参数 · multipart/form-data
filebinary 必填
要上传的文件。支持图片 JPG / JPEG / PNG / WEBP、音频 MP3 / WAV / FLAC、视频 MP4 / AVI / MOV / MKV;单文件 ≤ 50MB(生成任务对素材另有大小限制,见
提交视频任务 )。
终端 复制
curl -X POST https://api.zhaotutu.ai/v1/files/upload \
-H "Authorization: Bearer $SEEDANCE_API_KEY" \
-F "file=@/path/to/person.png"
响应
响应 · 200 复制
{
"url": "https://.../xxxx.png?q-sign-algorithm=...",
"file_type": "image",
"size": 3490,
"expires_in": 86400
}
把返回的 url 直接填入 images 或 metadata.content 即可。
⚠
链接仅 24 小时有效 (expires_in: 86400)。这不是图床 / 网盘服务,请在有效期内提交生成任务,不要用于长期存储或外链分发。
ℹ
频率限制:每个令牌每分钟最多 10 次 、每天最多 200 次 ,超限返回 429。
参考素材指南
所有图片 / 视频 / 音频参考素材都通过公网可直接下载的 URL 传入请求体。获得这样的 URL 有两种方式:
方式一:使用本站上传接口(推荐)
没有外链时,用 POST /v1/files/upload 把本地文件换成 24 小时有效的直链,免费且同样用 API Key 鉴权。
方式二:使用你自己的公网直链
素材已经在自己的对象存储(腾讯云 COS、阿里云 OSS、AWS S3 等)或稳定图床上时,直接填直链即可。要求:
必须是 http(s):// 直链:浏览器打开或 curl 请求该 URL 能直接得到文件本身 (Content-Type 为对应的图片 / 视频 / 音频类型);
不支持 base64 内嵌、本地文件路径、需要登录的链接、网盘分享页(百度网盘 / 阿里云盘等分享链接打开的是网页而不是文件,无法使用);
URL 需要在任务整个执行期间(提交后 10~30 分钟内)保持可访问,带签名的临时 URL 请确保有效期足够。
✓
素材不符合要求时(URL 不可达、格式不支持、超过大小限制),任务会提交失败或生成失败,费用全额退还 。
视频超分(Zhaotutu Upscaler)
独立能力分类:把已有视频提升到更高分辨率。对外模型名 zhaotutu-upscaler
(上游 rhart-video/video-upscaler)。
走与视频生成相同的异步接口 POST /v1/videos(兼容路径 POST /v1/video/generations),
但请求字段与文生/图生视频不同——必填输入视频,不需要文案提示词。
请求字段
字段 类型 必填 说明
model
string
是
固定为 zhaotutu-upscaler
metadata.content
array
是
恰好 1 条 video_url:{ "type": "video_url", "video_url": { "url": "https://..." } }。MP4,最长约 10 分钟;可先用 上传接口 换直链
metadata.resolution
string
否
目标分辨率 → 上游 targetResolution:720p / 1080p / 2k / 4k。默认 1080p
prompt
string
否
不参与上游提交;可填占位如 upscale
seconds
string
否
不参与上游提交;计费时长由上游从输入视频读取
提交示例
POST /v1/videos 复制
{
"model": "zhaotutu-upscaler",
"prompt": "upscale",
"metadata": {
"resolution": "1080p",
"content": [
{ "type": "video_url", "video_url": { "url": "https://your-cdn.example.com/source.mp4" } }
]
}
}
查询与结果
与普通视频任务相同:用 GET /v1/videos/{task_id} 轮询;成功后从结果中的视频直链下载转存。
计费(按输入视频时长 × 目标分辨率)
提交前通过 price-preview 全额预扣;成功后按 thirdPartyConsumeMoney 结算,多退少补。牌价(指导价 / fallback):
目标分辨率 单价(元 / 秒)
720p ¥0.14
1080p ¥0.21
2k ¥0.35
4k ¥0.56
最终以控制台实际扣减为准。与 Seedance 的「超分附加费」(生成后再升分辨率)不是同一套计费。
模型列表
视频模型(Seedance 2.0,共 18 个)
模型名由三段组成,2 个区域 × 3 个档位 × 3 种任务类型:
seedance-2.0- [global-] {tier} - {task}
片段 取值 说明
[global-]
省略 / global-
省略为国内版 (RunningHub.cn,人民币结算);带 global- 为国际版 (RunningHub.ai,美元结算后按汇率换算)。差异在上游站点与计费币种
{tier}
standard / fast / mini
Standard 质量最高(独占 native1080p / native4k 分辨率);Fast 出片更快;Mini 最便宜
{task}
t2v / i2v / multi
文生视频 / 图生视频 / 多模态视频
档位 文生视频 t2v 图生视频 i2v 多模态 multi
Standard 国内
seedance-2.0-standard-t2v
seedance-2.0-standard-i2v
seedance-2.0-standard-multi
Fast 国内
seedance-2.0-fast-t2v
seedance-2.0-fast-i2v
seedance-2.0-fast-multi
Mini 国内
seedance-2.0-mini-t2v
seedance-2.0-mini-i2v
seedance-2.0-mini-multi
Standard 国际
seedance-2.0-global-standard-t2v
seedance-2.0-global-standard-i2v
seedance-2.0-global-standard-multi
Fast 国际
seedance-2.0-global-fast-t2v
seedance-2.0-global-fast-i2v
seedance-2.0-global-fast-multi
Mini 国际
seedance-2.0-global-mini-t2v
seedance-2.0-global-mini-i2v
seedance-2.0-global-mini-multi
所有 Seedance 2.0 视频模型均支持 seed 参数和 seconds: "-1"(自动时长)。接口见 提交视频任务 。
视频模型(Seedance 2.5 Standard Token,共 6 个)
仅 Standard 档。国内 seedance-2.5-standard-*;海外 seedance-2.5-global-standard-*。分辨率 480p/720p/1080p/2k/4k/native1080p(无 native4k);时长 4–30s 或 metadata.duration=-1。多模态最多 50 个参考:30 图 + 10 视频 + 10 音频(单段音视频 2–30s,总长 ≤30s)。
区域 文生 t2v 图生 i2v 多模态 multi
国内 (.cn)
seedance-2.5-standard-t2v
seedance-2.5-standard-i2v
seedance-2.5-standard-multi
海外 (.ai)
seedance-2.5-global-standard-t2v
seedance-2.5-global-standard-i2v
seedance-2.5-global-standard-multi
视频模型(HappyHorse 1.1,共 3 个)
模型名 类型 说明
happyhorse-1.1-t2v
文生视频
prompt 必填;resolution=720p/1080p;seconds=3~15;可选 metadata.ratio(aspectRatio)
happyhorse-1.1-i2v
图生视频
需 images(取首图);prompt 可选;不支持 seconds=-1
happyhorse-1.1-r2v
参考图生视频
prompt 必填(可用「图1/图2」);images 1~9 张 → 上游 imageUrls;可选 metadata.ratio
按秒牌价:720p ¥0.69/s,1080p ¥0.92/s。接口同 提交视频任务 。
图片模型(Seedream / Dola / Zhaotutu Image G-2)
模型名 类型 说明
seedream-v5-pro-t2i
文生图(国内)
仅需 prompt;可选 resolution(1k/2k)或 width/height
seedream-v5-pro-i2i
图生图(国内)
prompt + images[](1~10 张参考图)
seedream-v5-pro-layer-decomposition
图层拆分(国内)
恰好 1 张 images[];prompt 可选;返回 1 张底图 + 最多 16 个 PNG 图层
dola-seedream-5.0-pro-t2i
文生图(海外)
字段同国内 t2i;上游 www.runninghub.ai / dola-Seedream-5.0-pro
dola-seedream-5.0-pro-i2i
图生图(海外)
字段同国内 i2i;上游 www.runninghub.ai
dola-seedream-5.0-pro-layer-decomposition
图层拆分(海外)
恰好 1 张 images[];返回底图与有序图层 URL;实测无 z_index / bounding_box
zhaotutu-image-g2-t2i
文生图(Zhaotutu Image G-2)
resolution 仅 1k;可选 metadata.ratio→aspectRatio;不支持 2k / output_format
zhaotutu-image-g2-i2i
图生图(Zhaotutu Image G-2)
prompt + images[];resolution 仅 1k;可选 metadata.ratio
接口见 提交图片任务 。
图片模型(Qwen-Image 3.0 / 3.0-Pro,共 8 个)
模型名 类型 说明
qwen-image-3.0-t2i
文生图(国内)
可选 n、size 或 ratio+resolution(1k/2k);省略 size 自动推荐
qwen-image-3.0-i2i
图像编辑(国内)
images[] 1–3;上游 image-edit
qwen-image-3.0-pro-t2i / qwen-image-3.0-pro-i2i
Pro 文生图 / 编辑(国内)
参数同上;Pro 牌价更高
qwen-image-3.0-global-* / qwen-image-3.0-global-pro-*
海外 .ai
请求直达 RunningHub.ai 海外站;USD 结算后按 结算汇率 换算
接口见 提交图片任务 。
Wan 2.7 Spicy(图生视频,1 个)
模型名 类型 说明
wan-2.7-spicy-i2v
图生视频
images[0] 必填;seconds 2–15;resolution 720p/1080p;可选 prompt / audio_url / negative_prompt / prompt_extend / seed
按秒牌价:720p ¥0.91/s,1080p ¥1.4/s。接口同 提交视频任务 。
Wan 3.0(视频,标准版与 Prime 高速版,国内与海外共 8 个)
模型名 类型 说明
wan-3.0-i2v图生视频 首帧必填、尾帧可选;2–30 秒或 auto;480P/720P/1080P
wan-3.0-r2v参考生视频 图片≤10、视频≤5、音频≤5;可选互斥的 file_url/link_url
wan-3.0-global-i2v海外图生视频 RunningHub.ai 美元计价;首帧必填、尾帧可选
wan-3.0-global-r2v海外参考生视频 RunningHub.ai 美元计价;file_url/link_url 自动开启深度思考
wan-3.0-prime-i2vPrime 国内图生视频 高速版;首帧必填、尾帧可选;2–30 秒或 auto
wan-3.0-prime-r2vPrime 国内参考生视频 高速版;图片≤10、视频≤5、音频≤5;可选 file_url/link_url
wan-3.0-global-prime-i2vPrime 海外图生视频 RunningHub.ai 美元计价
wan-3.0-global-prime-r2vPrime 海外参考生视频 RunningHub.ai 美元计价
比例支持 adaptive/16:9/4:3/1:1/3:4/9:16;音频默认开启;seed 0–2147483647。标准版 fallback 每秒 ¥0.30/¥0.60/¥1.20;2026-08-24 企业 Key 实测每秒 ¥0.21/¥0.42/¥0.84。Prime 国内 fallback 每秒 ¥0.43/¥0.86/¥1.71,Prime 海外为每秒 $0.06/$0.13/$0.27 并按汇率折算。终态按上游实际消费结算,成功结果为单个 MP4 URL。
RunningHub OpenAPI 媒体模型(共 68 个,按次计费)
ℹ
这三家均为按次计费 (按上游 thirdPartyConsumeMoney 结算),不是 Seedance 的 Token 按量。提交前 price-preview 预扣,成功后按实际金额结算,失败全额退款。接口同 提交视频任务 。
Wan 2.7 海外图片(3 个)
模型名 类型 说明
wan-2.7-global-t2i文生图 prompt ≤5000;可选 width/height 512–4096、thinking_mode
wan-2.7-global-i2i图像编辑 images[] 1–9;prompt ≤2048
wan-2.7-global-i2i-pro图像编辑 Pro images[] 1–9;最高 2K;prompt ≤2048
使用 /v1/image/generations 提交;请求直达 RunningHub.ai,USD 成本按 结算汇率 换算。
可灵 Kling(28)
模型名 类型
kling-v3.0-std-t2v / kling-v3.0-pro-t2v文生视频 v3.0
kling-v3.0-std-i2v / kling-v3.0-pro-i2v图生视频 v3.0(首帧,可选尾帧)
kling-v3-turbo-std-t2v / kling-v3-turbo-pro-t2v文生视频 v3 turbo
kling-v3-turbo-std-i2v / kling-v3-turbo-pro-i2v图生视频 v3 turbo
kling-v3-4k-t2v / kling-v3-4k-i2v文生 / 图生 4K
kling-o3-std-t2v / kling-o3-pro-t2v文生视频 o3
kling-o3-std-i2v / kling-o3-pro-i2v图生视频 o3
kling-o3-std-r2v / kling-o3-pro-r2v参考生视频 o3
kling-o3-std-edit / kling-o3-pro-edit视频编辑(需 video_url)
kling-o3-4k-t2v / kling-o3-4k-i2v / kling-o3-4k-r2vo3 4K
kling-v3.0-std-motion / kling-v3.0-pro-motion / kling-v3.0-4k-motion动作控制(图+视频)
kling-elements-advancedo3 多主体
kling-lip-sync-identify-face / kling-lip-sync-tts / kling-lip-sync-video对口型多步套件
海螺 Hailuo 2.3(6)
模型名 类型
hailuo-2.3-t2v-standard / hailuo-2.3-t2v-pro文生视频
hailuo-2.3-i2v-standard / hailuo-2.3-i2v-pro图生视频
hailuo-2.3-fast-i2v / hailuo-2.3-fast-pro-i2v图生视频 fast
海螺 Hailuo H3(6,国内 + 海外)
模型名 类型
hailuo-h3-t2v / hailuo-h3-global-t2v文生视频(768P/2K,时长 5–15s,可选 ratio)
hailuo-h3-i2v / hailuo-h3-global-i2v图生视频(首帧必填,可选尾帧)
hailuo-h3-multi / hailuo-h3-global-multi多模态参考生视频(图≤9 / 视频≤3 / 音频≤3)
global 变体走 RunningHub.ai 海外 Key,并按美元成本换算人民币结算。
MiniMax H3 Max(2,RunningHub.cn)
模型名 类型与参数
hailuo-h3-max-t2v文生视频;prompt 必填;480P/768P;5–15 秒;六种 ratio 必填
hailuo-h3-max-i2v首尾帧图生视频;images 1–2 张依次映射首帧/尾帧;480P/768P;5–15 秒
牌价为 480P ¥0.41/秒、768P ¥0.63/秒;任务完成后按 RunningHub 返回的人民币 thirdPartyConsumeMoney 结算。
MiniMax H3 Max Turbo(2,RunningHub.cn)
模型名 类型与参数
hailuo-h3-max-turbo-t2v文生视频;prompt 必填;小写 480p/768p;5–15 秒;六种 ratio 必填并映射 aspectRatio
hailuo-h3-max-turbo-i2v首尾帧图生视频;images 1–2 张依次映射必填首帧/可选尾帧;小写 480p/768p;5–15 秒;不接受 ratio
牌价为 480p ¥0.175/秒、768p ¥0.28/秒;任务完成后按 RunningHub 返回的人民币 thirdPartyConsumeMoney 结算。公开 API 不暴露上游 webhookUrl。RH 未声明 prompt 长度上限;网关 20480 字符限制仅为保护值。
MiniMax H3 Context IR(3,返回增强提示词)
这三个模型只增强视频提示词,不生成视频。提交 POST /v1/video/generations,轮询 GET /v1/video/generations/{id};成功响应的增强提示词位于 result_text。
模型名 参数
minmax-h3-context-ir-textprompt 1–7000 字符;seconds 4–15;metadata.ratio 必填
minmax-h3-context-ir-image另需 images 1–2 张,映射首帧/尾帧
minmax-h3-context-ir-multimodal图≤9 / 视频≤3 / 音频≤3;比例可选并支持 adaptive
三个模型均按上游实际人民币 thirdPartyConsumeMoney 结算。
FLUX 3 Video(8,国内 + 海外)
模型名 类型
flux-3-video-t2v / flux-3-video-global-t2v文生视频
flux-3-video-i2v / flux-3-video-global-i2v图生视频(1–10 张关键帧)
flux-3-video-v2v / flux-3-video-global-v2v视频续生(需 metadata.video_url)
flux-3-video-draft-enhance / flux-3-video-global-draft-enhance草稿增强(需上一草稿任务返回的 metadata.draft_cache)
生成参数:5–20s,hd/fhd,8 种比例;可选草稿、同步音频与 0–4 审核容忍度。global 变体走 RunningHub.ai。
Minimax H3 OW / FlashVSR / VOSR2(RH AI App,11)
模型名 类型
minimax-h3-ow-t2v全能视频(480p/720p;时长 5/10/15s;最多 9 图 + 3 音频 + 3 视频任意组合)
minimax-h3-ow-r2v全能参考视频(同上参数/定价;最多 9 图 + 3 音频 + 3 视频任意组合)
minimax-h3-ow-i2v全能视频(同上参数/定价;最多 9 图 + 3 音频 + 3 视频任意组合)
minimax-h3-ow-r2v-fast全能极速参考视频(独立定价;最多 9 图 + 3 音频 + 1 视频任意组合;含视频时同档价格 ×1.5)
minimax-h3-ow-i2v-fast全能极速视频(独立定价;最多 9 图 + 3 音频 + 3 视频任意组合)
minimax-h3-ow-fl2va-audio-drive-fast极速音频驱动视频(必填且仅支持 1 张人物图与 1 条音频 URL)
minimax-h3-ow-ref2va-audio-drive-fast极速参考音频驱动视频(必填且仅支持 1 张参考图与 1 条音频 URL)
minimax-h3-ow-t2v-fast全能极速视频(独立定价;最多 9 图 + 3 音频 + 3 视频任意组合)
FlashVSR_video_upscaleMiniMax H3 480P→1080P 视频放大;输入 480P、3–15 秒;仅一个 metadata.video_url;固定 ¥1/次
vosr2-video-upscaleVOSR2 视频高清化;仅一个 metadata.video_url;输出 2K;按 RunningHub 实际人民币用量结算
vosr2-image-upscaleVOSR2 图像高清化;仅一张 images;输出 4K;按 RunningHub 实际人民币用量结算
t2v / r2v / i2v 固定零售(元):480p 5/10/15s = 0.2/0.5/1.0;720p 5/10/15s = 0.5/1.0/2.0。fast 五个 SKU 固定零售(元/次):480p 5/10/15 秒 = 0.3/0.5/1.0;720p 对应为 2 倍 = 0.6/1.0/2.0;t2v/i2v/r2v 与对应 fast SKU 统一提交 AI App 2093306716501929986,六者最多支持 9 图 + 3 音频;三个非 fast SKU 和 t2v-fast/i2v-fast 最多 3 视频,r2v-fast 最多 1 视频。所有媒体输入均可选,每个参考视频不超过 15 秒;只有 r2v-fast 含 1 个视频参考时按同档无视频价格的 1.5 倍计费;fl2va-audio-drive-fast/ref2va-audio-drive-fast 仅支持 1 张图和 metadata.audio_urls[0] 1 条音频 URL;megapixels 分别映射为 0.4 / 1。经 RunningHub AI 应用接口,强制 instanceType=ultra。
FlashVSR_video_upscale 复用同一 AI App 渠道 Key,提交到 run/ai-app/2084910543957217281 的 24.file,强制 instanceType=plus;固定 ¥1/次且账上成本为 0。
vosr2-video-upscale 提交到 run/ai-app/2096973451201441794 的 7.video,强制 instanceType=plus;vosr2-image-upscale 提交到 run/ai-app/2096970236741378049 的 3.image,使用 instanceType=standard。两者均按终态 usage.thirdPartyConsumeMoney 的人民币实际用量结算。
Vidu Q3(15)
模型名 类型
vidu-q3-pro-t2v / vidu-q3-turbo-t2v / vidu-q3-pro-fast-t2v文生视频
vidu-q3-pro-i2v / vidu-q3-turbo-i2v / vidu-q3-pro-fast-i2v图生视频
vidu-q3-pro-start-end / vidu-q3-turbo-start-end / vidu-q3-pro-fast-start-end首尾帧
vidu-q3-r2v / vidu-q3-mix-r2v / vidu-q3-ad-r2v / vidu-q3-drama-r2v参考生视频
vidu-q3-drama-short-play / vidu-q3-ad-short-play短剧成片
字段细节与特殊参数见 Markdown 文档 llms.txt 对应章节。
Image G v2.5:Flare / Sunburst
zhaotutu-image-g-v2.5-flare 官方版。支持文生图与参考图编辑,适合日常创作与快速迭代。zhaotutu-image-g-v2.5-sunburst 官方版。支持文生图与参考图编辑,侧重精细编辑。
提交 POST /v1/image/generations,通过 GET /v1/image/generations/{id} 查询结果。添加 images 即进入编辑模式;省略 size 可保留参考图比例。按实际消耗结算,失败全额退款,金额以控制台为准。
参数 取值与说明
model / prompt必填;使用上述完整模型名和生成或编辑描述。
images可选,最多 16 张公开 HTTP(S) 图片地址。
n整数 1–4,默认 1。
size可省略,或 auto / 1:1 / 3:2 / 2:3 / 4:3 / 3:4 / 5:4 / 4:5 / 16:9 / 9:16 / 2:1 / 1:2 / 21:9 / 9:21 / 3:1 / 1:3,也支持 1600x1200 等像素尺寸。宽高须为 16 的倍数且均不超过 3840,最长边与最短边之比不超过 3:1,总像素为 655360–8294400。
resolution1k / 2k / 4k,默认 1k;指定精确像素尺寸时忽略。
qualityauto / low / medium / high / xhigh / max。默认 auto;示例使用 low。auto 在生成时选择质量,最终按实际消耗结算。
output_formatpng / jpeg / webp,默认 png。
output_compression可选整数 0–100,仅 jpeg / webp 可用,png 请省略。
backgroundauto / transparent / opaque;透明背景仅支持 png / webp。
moderationlow / auto,默认 low。
文生图示例 复制
curl https://api.zhaotutu.ai/v1/image/generations \
-H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"model":"zhaotutu-image-g-v2.5-flare","prompt":"A red ceramic teapot on a white table","resolution":"1k","quality":"low","n":1}'
编辑时改用所需模型并添加 "images":["https://example.com/reference.png"]。返回任务 ID 后轮询至成功,及时保存结果图片。暂不支持流式图片。
Image G v2.5:低价扩展版
低价扩展版,支持文生图和参考图编辑,提供 1k / 2k / 4k 输出。上游正在灰度升级,实际模型版本随账号升级进度而定。
提交 POST /v1/image/generations,通过 GET /v1/image/generations/{id} 查询结果。按实际消耗结算,失败全额退款,金额以控制台为准。
参数 取值与说明
model必填:zhaotutu-image-g-v2.5-lowprice。
prompt必填,1–5000 字符,描述生成或编辑需求。
images可选,最多 15 张公开 HTTP(S) 图片地址,按输入顺序参与编辑。
n仅支持 1,每次返回一张图片。
sizeauto / 1:1 / 1:3 / 3:1 / 16:9 / 9:16 / 4:3 / 3:4 / 3:2 / 2:3 / 5:4 / 4:5 / 2:1 / 1:2 / 21:9 / 9:21;默认 16:9,auto 根据提示词或参考图决定比例。
resolution1k / 2k / 4k,默认 1k。
nsfw_check布尔值 true / false,默认 false,控制生成前的内容安全检查。
文生图示例 复制
curl https://api.zhaotutu.ai/v1/image/generations \
-H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"model":"zhaotutu-image-g-v2.5-lowprice","prompt":"A red ceramic teapot on a white table","resolution":"1k","size":"16:9","n":1,"nsfw_check":false}'
编辑时添加 "images":["https://example.com/reference.png"],可使用 "size":"auto"。结果图片直链约 24 小时过期,请及时保存。此扩展版不提供质量档位、输出格式、透明背景或流式选项。
Zhaotutu 扩展视频 / 图片
视频(6)
模型名 说明
zhaotutu-video-gk-v15
文生/图生视频。seconds 6–30(默认 6);resolution 480p/720p;metadata.ratio 16:9/9:16/1:1/3:2/2:3;可选 images≤7
zhaotutu-video-v31-fast
视频(fast)。时长固定 8s;resolution 720p/1080p/4k;ratio 16:9/9:16;images≤3(1=首帧,2=首尾帧,3=reference);可选 metadata.type=frame/reference
zhaotutu-video-v31-quality
视频(quality)。同 fast,但禁止 reference (勿传 type=reference 或 3 张参考图)
zhaotutu-video-v31-lite
视频(lite)。仅文生视频 ;勿传 images / metadata.type;时长固定 8s;resolution 720p/1080p/4k;ratio 16:9/9:16
zhaotutu-video-g-omni-flash
多模态视频(文/图/视频编辑)。prompt 和/或 images≤16 / metadata.video_url(≤1)/ metadata.extend_from_task_id(与 video_url 互斥);resolution 仅 720p;时长不可指定
zhaotutu-video-g-omni-flash-lowprice
文生、图生与参考视频生成。prompt 必填;seconds 为 4/6/8/10(默认 6);resolution 为 720p/1080p/4k;aspect_ratio 为 16:9/9:16;images 支持 0/1/3 张;参考视频使用 metadata.video_url(≤1)并省略时长
zhaotutu-video-g-omni-1.1-flash-lowprice
文生、图生与参考视频生成。prompt 必填;seconds 为 4/6/8/10(默认 6);resolution 为 720p/1080p/4k;aspect_ratio 为 16:9/9:16;images 支持 0/1/3 张;参考视频使用 metadata.video_url(≤1)并省略时长
图片
模型名 说明
zhaotutu-image-g-v2.5-lowprice低价扩展版,1k / 2k / 4k,最多 15 张参考图、单张输出;上游灰度升级中。参数与示例
zhaotutu-image-g-v2.5-flare文生图与参考图编辑,最多 16 张参考图,1k / 2k / 4k,自定义尺寸,1–4 张输出。参数与示例
zhaotutu-image-g-v2.5-sunburst文生图与精细参考图编辑,参数同 Flare。参数与示例
zhaotutu-image-g-v2-lowprice
文生图/图生图。resolution 1k/2k/4k;顶层 n 1–10;size(或 metadata.ratio)比例枚举或 WxH;可选 images≤16
zhaotutu-image-gk-v15
文生图。n 1–10;size 1:1/16:9/9:16/3:2/2:3
zhaotutu-image-gk-v15-edit
图编辑。必填 images[](取首张);n 1–10
zhaotutu-image-gk-v2
Grok Imagine 2.0 仅文生图,不接受 images。n 1–12;size 1:1/2:3/3:2/3:4/4:3/9:16/16:9;resolution 可省略或为 quality
zhaotutu-image-gk-v2-edit
图编辑/多图参考。必填 images 1–3 张;n 1–10;aspect_ratio 为 auto 或 13 种固定比例;resolution 为 1k/2k;可选 nsfw_check;不接受 quality
zhaotutu-image-gk-v2-segment
对象分割。operation=segment;必填 source_task_id;免费;完成结果位于 data.content.result
zhaotutu-image-gk-v2-region-edit
区域编辑。operation=region_edit;必填 image_id、prompt;选区可使用多边形、边界框或对象索引
zhaotutu-image-nb-flash
Nano Banana。文生图/图生图;resolution 仅 1k;n=1;size 含 auto/21:9;可选 images≤14;prompt≤1000
zhaotutu-image-nb-2
Nano Banana 2。文生图/图生图;resolution 0.5k/1k/2k/4k;n=1;含极端比例 1:8/8:1;可选 images≤14
zhaotutu-image-nb-2-lite
Nano Banana Lite。文生图/图生图;resolution 仅 1k;n 1–4;可选 images≤14
zhaotutu-image-nb-pro
Nano Banana Pro。文生图/图生图;resolution 1k/2k/4k;n=1;可选 images≤14
字段细节与 curl 示例见 llms.txt 「Zhaotutu 扩展」章节。
视频超分(Zhaotutu Upscaler,1 个)
独立分类,详见 视频超分 。模型:zhaotutu-upscaler。
Midjourney
ℹ
完整接口文档见侧栏 Midjourney 树:
概览 ·
Imagine ·
最佳实践 ·
完整工作流 等。
计费:按实际上游消耗结算,失败全额退款;轮询 GET /v1/midjourney/tasks/{id}。
Suno 音乐
ℹ
完整接口文档见侧栏 Suno 树:
概览 ·
Generate music 等全部分页。
计费:按实际上游消耗结算(部分工具按次),失败全额退款;轮询 GET /v1/music/tasks/{id}。
音频模型(Doubao Seed Audio 1.0,共 1 个)
模型名 类型 说明
doubao-seed-audio-1.0
音频生成
POST /v1/audio/generations;prompt 必填;可选 metadata.speaker / 参考音频 / images(互斥)
mureka-v8-bgm / mureka-v9-bgm
伴奏生成
POST /v1/audio/generations;prompt / metadata.instrumental_id 二选一;metadata.n 1–3;¥0.34/条
Seed Audio 牌价约 ¥0.004/秒;Mureka 牌价 ¥0.34/条。接口见 提交音频任务 。
Flow Music
ℹ
完整接口文档见侧栏 Flow Music 树:
生成音乐 ·
生成歌词 ·
续写 ·
任务查询 等全部分项。
请求体使用 model=flowmusic,可选版本 lyria-3.5;
成功任务按实际上游消耗结算,失败全额退款;轮询 GET /v1/music/tasks/{id}。
文本对话(DeepSeek / Qwen / GLM / GK / GPT / GM / Kimi,共 13 个)
模型名 类型 说明
deepseek/deepseek-v4-flash-vision-exp
多模态对话
POST /v1/chat/completions(同步/流式);RH 国内实验版;1,048,576 tokens 上下文;支持图片输入、工具调用和结构化输出
glm/glm-5.3-flash
文本对话
POST /v1/chat/completions(同步/流式);RH 国内;262,144 tokens 上下文
glm-5.3
文本对话
POST /v1/chat/completions(同步/流式);RH 国内;1,048,576 tokens 上下文;纯文本、始终推理
qwen/qwen3.8-flash-next
文本对话
POST /v1/chat/completions(同步/流式);RH 国内;262,144 tokens 上下文
qwen/qwen3.8-max
文本对话
POST /v1/chat/completions(同步/流式);OpenAI 兼容;1M 上下文;支持工具调用、推理、Web Search 与结构化输出
zhaotutu/gk-4.6
文本对话
POST /v1/chat/completions(同步/流式);OpenAI 兼容;500K 上下文;支持视觉、工具调用与推理;200K tokens 起进入长上下文价格档
zhaotutu/g6-astra
多模态对话
POST /v1/chat/completions(同步/流式);OpenAI 兼容;1,050,000 tokens 上下文;支持视觉、工具调用与推理;272K tokens 后进入长上下文价格档
zhaotutu/g5.6-sol多模态对话 POST /v1/chat/completions(同步/流式);1,050,000 tokens 上下文;支持视觉、工具调用与推理;272K tokens 后进入长上下文价格档
zhaotutu/g5.6-terra多模态对话 POST /v1/chat/completions(同步/流式);1,050,000 tokens 上下文;支持视觉、工具调用与推理;272K tokens 后进入长上下文价格档
zhaotutu/g5.6-luna多模态对话 POST /v1/chat/completions(同步/流式);1,050,000 tokens 上下文;支持视觉、工具调用与推理;272K tokens 后进入长上下文价格档
zhaotutu/g5.5多模态对话 POST /v1/chat/completions(同步/流式);1,050,000 tokens 上下文;支持视觉、工具调用与推理;272K tokens 后进入长上下文价格档
zhaotutu/gm-3.8-flash多模态对话 POST /v1/chat/completions(同步/流式);1,048,576 tokens 上下文;支持视觉、工具调用与推理;按输入/输出/缓存命中用量计费
kimi-k3
文本对话
POST /v1/chat/completions(同步/流式);OpenAI 兼容;约 1M 上下文
接口见 文本对话 。
语音转写(Whisper,共 1 个)
模型名 类型 说明
whisper-1
语音转写
POST /v1/audio/transcriptions(同步 multipart);按时长计费,1 分钟 = 1000 tokens
接口见 语音转写 。
价格与计费
ℹ
可灵 / 海螺 / Vidu 为按次计费 ;Zhaotutu 扩展 / Suno / Midjourney 按上游消耗结算。下方 Token 公式仅适用于 Seedance 2.0 视频模型。
Seedance 按任务实际消耗的 Token 数 计费,任务成功后结算;选择 1080p / 2k / 4k 超分档时,另按输出视频时长收取超分附加费:
计费公式 复制
总费用 = Token 单价 × 实际消耗 Token 数 ÷ 1,000,000
+ 超分附加费单价 × 输出视频时长(秒) # 仅 1080p / 2k / 4k 档
ℹ
Token 消耗量由模型在任务完成后返回,与分辨率、时长、内容复杂度相关,提交前只能估算区间 。建议先用低分辨率、短时长试跑,统计 Token 用量后再评估成本。最终计费以控制台余额扣减为准。
Token 单价(元 / 百万 Token)
多模态模型(-multi)传入参考视频(video_url)时,按「有参考视频」的低单价档计费;文生视频、图生视频均按「无参考视频」档计费。国内版与国际版价格相同。
档位 分辨率 无参考视频 有参考视频
Standard 480p / 720p ¥46 ¥28
1080p / 2k / 4k / native1080p ¥51 ¥31
native4k ¥26 ¥16
Fast 全部分辨率 ¥37 ¥22
Mini 全部分辨率 ¥23 ¥14
ℹ
native4k 的 Token 单价 最低,但 4K 原生输出单位时长消耗的 Token 数远高于低分辨率,总价并不低。native1080p / native4k 仅 Standard 档支持。
超分附加费(元 / 秒,按输出时长计)
分辨率 附加费
480p / 720p / native1080p / native4k 免费
1080p ¥0.28
2k ¥0.42
4k ¥0.63
计费示例
假设一个 seedance-2.0-standard-t2v(无参考视频)任务,选择 1080p,生成了 5 秒视频,实际消耗 400,000 Token:
演算 复制
Token 费用 = ¥51 × 400,000 ÷ 1,000,000 = ¥20.40
超分附加费 = ¥0.28 × 5 秒 = ¥ 1.40
─────────────────────────────────────────────
总费用 = ¥21.80 (示例中的 Token 数仅为演示,实际以任务返回为准)
✓
多退少补,失败退款。 提交任务时预扣的额度仅为占位,任务成功后按实际用量结算并自动退还差额;提交失败、生成失败均全额退款。
图片计费(Seedream)
图片任务按上游实际消费金额结算(提交前通过价格预估全额预扣,成功后多退少补):
计费公式 复制
总费用 = 上游 thirdPartyConsumeMoney(人民币)
参考场景(实测) 约合费用
seedream-v5-pro-t2i · resolution=2k≈ ¥0.54 / 张
seedream-v5-pro-i2i · resolution=1k≈ ¥0.27 / 张
seedream-v5-pro-layer-decomposition≤236 万像素 ¥0.27/张;更高 ¥0.54/张
dola-seedream-5.0-pro-layer-decomposition≤236 万像素 $0.041/张;更高 $0.081/张(USD→CNY)
最终以控制台实际扣减为准;分辨率、宽高、内容复杂度会影响价格。
Zhaotutu 扩展模型计费
按实际消耗结算(人民币):提交预扣 → 成功多退少补 → 失败全额退款。结果 URL 约 24 小时过期。最终以控制台余额扣减为准。
Midjourney 计费(按上游 cost USD)
计费公式 复制
按任务完成后的实际上游消耗结算为人民币;提交预扣,成功多退少补,失败全额退款。具体金额以控制台预估与余额变动为准。
实测参考:midjourney-imagine @ v6.1 relax 单次 cost≈0.045 USD(四宫格)。失败全额退款;本地 400 零扣费。
Suno 计费(按上游 cost USD)
与 Zhaotutu 扩展同属「上游 USD cost × 汇率」结算路径(多数生成类 action):
计费公式 复制
按任务完成后的实际上游消耗结算为人民币(部分工具类按次);提交预扣,成功多退少补,失败全额退款。具体金额以控制台预估与余额变动为准。
实测参考:suno-generation @ v3.5 单次 cost≈0.05 USD(常出 2 轨)。部分工具类 action 无 cost,按次计费。提交失败 / 生成失败全额退款;本地 400 零扣费。
视频超分计费(Zhaotutu Upscaler)
按输入视频时长 × 目标分辨率单价 结算,详见 视频超分 。牌价:720p ¥0.14/s、1080p ¥0.21/s、2k ¥0.35/s、4k ¥0.56/s。与上方 Seedance「超分附加费」无关。
错误处理
HTTP 场景 响应示例
400
缺少必填参数(如 prompt)
{"code":"invalid_request","message":"prompt is required"}
400
缺少任务类型所需素材(如 i2v 缺 images)
{"code":"fail_to_fetch_task","message":"...image-to-video requires at least one input image..."}
401
鉴权失败
缺少或格式错误的 Authorization 头
429
上传接口超过频率限制
每令牌每分钟 10 次 / 每天 200 次
503
model 不存在 / 未挂载
{"error":{"code":"model_not_found","message":"No available channel for model ..."}}
提交失败时不会真正扣费,预扣额度会全额退还。生成阶段失败通过查询接口的 status: "failed" 与 error 字段返回,同样全额退款。
Midjourney、Suno 与 Flow Music 完整 API 文档
路径与参数对齐本站 https://api.zhaotutu.ai。请求 / 响应示例见右侧多语言卡片。
Flow Music 路径 SKU: flowmusic-generation · flowmusic-lyrics · flowmusic-extend · flowmusic-replace · flowmusic-cover · flowmusic-stems · flowmusic-upload-audio · flowmusic-download-audio · flowmusic-video-clip
Midjourney API 概览
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
Midjourney 文生图(Imagine)/ 垫图 / 二次操作 / 图生视频接口总览
异步任务模式:提交后返回 task_id,轮询查询结果
新版路由自动注入 model=midjourney,支持原生 MJ 参数、body 结构化参数与 metadata
Base URL: https://api.zhaotutu.ai
鉴权: Authorization: Bearer <token>
新版 /v1/midjourney/... 路由会自动注入 model=midjourney,请求体不需要传 model。
快速开始
# 1. 提交绘图
curl -X POST https://api.zhaotutu.ai/v1/midjourney/generations \
-H "Authorization: Bearer <token>" \
-H "Content-Type: application/json" \
-d '{"prompt": "a cute cat, watercolor style --ar 16:9"}'
# 2. 查询结果(推荐轮询统一任务接口直到 status=completed)
curl https://api.zhaotutu.ai/v1/tasks/task_01JWXXXX \
-H "Authorization: Bearer <token>"
# 3. 放大第1张图
curl -X POST https://api.zhaotutu.ai/v1/midjourney/generations/upscale \
-H "Authorization: Bearer <token>" \
-H "Content-Type: application/json" \
-d '{"task_id": "task_01JWXXXX", "index": 1}'
接口总览
每个功能的完整字段、示例、注意事项见对应子页面。
功能
路径
文档
文生图(默认入口)
POST /v1/midjourney/generations
Imagine
文生图(显式入口)
POST /v1/midjourney/generations/imagine
Imagine
多图融合
POST /v1/midjourney/generations/blend
Blend
图生文(识图)
POST /v1/midjourney/generations/describe
Describe
图片编辑
POST /v1/midjourney/generations/edits
Edits
放大选图
POST /v1/midjourney/generations/upscale
Upscale
生成变体
POST /v1/midjourney/generations/variation
Variation
大幅变体
POST /v1/midjourney/generations/high-variation
High Variation
微调变体
POST /v1/midjourney/generations/low-variation
Low Variation
重新生成
POST /v1/midjourney/generations/reroll
Reroll
缩放扩展
POST /v1/midjourney/generations/zoom
Zoom
平移扩展
POST /v1/midjourney/generations/pan
Pan
局部重绘
POST /v1/midjourney/generations/inpaint
Inpaint
Modal 补充参数
POST /v1/midjourney/generations/modal
Modal
图生视频
POST /v1/midjourney/generations/video
Video
重塑(强 / 弱)
POST /v1/midjourney/generations/remix-strong · /remix-subtle
Remix
任务查询
GET /v1/tasks/{task_id} · /v1/midjourney/{task_id}
任务查询
参考:最佳实践 (轮询 / 重试 / 排错) · 完整工作流示例 (端到端 curl + 客户端封装)
完整使用流程
flowchart TB
A["① POST /generations<br/>提交 Imagine"] --> B["② GET /v1/tasks/{task_id}<br/>轮询至 completed"]
B --> C["③ 如需按钮<br/>GET /v1/midjourney/{task_id}"]
C --> D1["/upscale"]
C --> D2["/variation"]
C --> D3["/reroll"]
C --> D4["/zoom"]
C --> D5["/inpaint<br/>(进入 MODAL)"]
D5 --> M["/modal<br/>提交遮罩 + prompt"]
错误处理
错误响应格式
{
"error": {
"type": "invalid_request_error",
"message": "prompt is required"
}
}
常见错误
HTTP 状态码
type
说明
400
invalid_request_error
参数错误(缺少必填、格式错误等)
401
authentication_error
API Key 无效
402
payment_required
余额不足
404
not_found
任务不存在
429
rate_limit_error
请求频率超限
500
internal_error
服务器内部错误
任务失败
fail_reason 常见值:
Banned prompt detected — 提示词含违禁内容
Task timeout — 任务超时(超过 30 分钟未完成),已自动退款
No available upstream — 服务暂不可用,请稍后重试
计费说明
MJ 新版统一模型名是 midjourney,通过 action、version、speed 生成计费 key。匹配顺序通常为:
midjourney@<action>-<version>-<speed>
-> midjourney@<action>-<version>
-> midjourney@<action>-<speed>
-> midjourney@<action>
-> midjourney
操作
计费名称
说明
Imagine
midjourney@imagine[-version][-speed]
文生图 / 垫图
Blend
midjourney@blend[-speed]
多图融合
Describe
midjourney@describe[-speed]
图生文
Edits
midjourney@edits[-speed]
图片编辑
Upscale
midjourney@upscale[-version][-speed]
放大
Variation
midjourney@variation[-version][-speed]
变体
High Variation
midjourney@high_variation[-version][-speed]
强变体
Low Variation
midjourney@low_variation[-version][-speed]
弱变体
Reroll
midjourney@reroll[-version][-speed]
重新生成
Zoom
midjourney@zoom[-version][-speed]
缩放扩图
Pan
midjourney@pan[-version][-speed]
平移扩图
Inpaint
midjourney@inpaint[-version][-speed]
局部重绘入口
Modal
midjourney@modal[-speed]
局部重绘补参
Video
midjourney@video / midjourney@video-720p
图生视频,实扣 × batch_size
Remix Strong
midjourney@remix_strong[-speed]
强重塑(仅 v8.1 / v8.2)
Remix Subtle
midjourney@remix_subtle[-speed]
弱重塑(仅 v8.1 / v8.2)
说明:
speed=relax 或未传 speed 时,不追加 speed 后缀;fast / turbo 会追加对应后缀。
主版本归一化为 v8.2、v8.1、v7、v6.1、v5.2、v5.1。
niji=true + version=7/6 归一化为 niji7 / niji6。
具体价格以控制台模型定价页为准。任务失败会自动全额退款。
Imagine(文生图)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
Midjourney 文生图 / 垫图。默认入口 /v1/midjourney/generations 与显式入口 /imagine 行为一致
默认文生图 / 垫图接口,等同于 imagine。显式入口 /v1/midjourney/generations/imagine 行为一致。
项目
内容
action
IMAGINE
计费
midjourney@imagine[-version][-speed]
必填
prompt
可选
image_urls、Prompt 参数、speed、metadata
请求参数
字段
类型
必填
说明
prompt
string
是
提示词,支持原生 MJ 参数(如 --ar 16:9 --v 6.1)
speed
string
否
速度模式:relax(默认)/ fast / turbo
image_urls
string[]
否
垫图 URL(图生图场景),支持 URL 或 base64
metadata
object
否
自定义元数据,会随任务保存,便于业务侧追踪
结构化参数(可选)
以下参数可以写在 body 里,也可以直接写在 prompt 中(如 --ar 16:9)。body 优先级高于 prompt。
字段
类型
等价 MJ 参数
说明
size
string
--ar
宽高比,如 "16:9", "1:1", "9:16"
quality
string
--q
质量:"0.25", "0.5", "1", "2"
style
string
--style
风格:"raw" 等
version
string
--v
版本号。主版本会追加为 --v <version>;与 niji: true 搭配 "7" / "6" 时会归一化为 Niji 版本
seed
int
--seed
随机种子
negative_prompt
string
--no
负面提示词,如 "ugly, blurry"
stylize
int
--s
风格化强度 (0-1000)
chaos
int
--c
混乱度 (0-100)
weird
int
--w
怪异度 (0-3000)
tile
bool
--tile
平铺模式
niji
bool
--niji
Niji 开关。推荐传 niji: true + version: "7" / "6"
iw
float
--iw
图片权重 (0-3),垫图时使用
cw
int
--cw
角色权重 (0-100)
sw
int
--sw
风格权重 (0-1000)
cref
string
--cref
角色参考图 URL
sref
string
--sref
风格参考图 URL
dref
string
--dref
深度参考图 URL
dw
float
--dw
深度权重 (0-100)
repeat
int
--repeat
重复生成次数 (2-40)
raw
bool
--raw
原始风格 (v5.1+ 支持)
draft
bool
--draft
草图模式 (v7+ 支持)
hd
bool
--hd
HD 高清 (仅 v8.1 / v8.2,未传 version 时后端自动补 --v 8.1)
stop
int
--stop
提前停止 (10-100,仅 v5-6.1 / niji 5-6)
extra
string
任意 --xxx
逃生口,原样追加到 prompt 末尾
示例
方式一:参数写在 prompt 里
{
"prompt": "a beautiful sunset over mountains --ar 16:9 --v 6.1 --style raw --s 750"
}
方式二:参数写在 body 里(推荐)
{
"prompt": "a beautiful sunset over mountains",
"size": "16:9",
"version": "6.1",
"style": "raw",
"stylize": 750
}
主版本与 Niji 版本
{
"prompt": "anime girl in a moonlit garden",
"niji": true,
"version": "7",
"size": "9:16"
}
线上已验证可用版本:8.2、8.1、7、6.1、5.2、5.1、niji 7、niji 6。主版本使用 body 字段 version;Niji 推荐传 niji: true + version: "7" / "6",计费版本会归一化为 niji7 / niji6。
方式三:混合使用(body 优先)
{
"prompt": "a beautiful sunset --ar 1:1",
"size": "16:9"
}
最终 prompt: a beautiful sunset --ar 16:9(body 中的 size 覆盖了 prompt 中的 --ar 1:1)
图生图(垫图)
{
"prompt": "turn this product into a luxury studio photo",
"image_urls": ["https://example.com/product.png"],
"size": "1:1",
"iw": 1.2
}
Fast 模式
{
"prompt": "a cute cat",
"speed": "fast"
}
speed=relax 或未传 speed 时不追加计费 speed 后缀;fast / turbo 会通过对应速度通道生效,并匹配对应计费 key。
响应
{
"code": 200,
"data": [{
"status": "submitted",
"task_id": "task_01JWXXXXXXXXXXXX"
}]
}
成功后通过任务查询 轮询结果。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"prompt": "a beautiful sunset over mountains",
"size": "16:9",
"version": "6.1",
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations"
payload = {
"prompt": "a beautiful sunset over mountains",
"size": "16:9",
"version": "6.1",
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations";
const payload = {
prompt: "a beautiful sunset over mountains",
size: "16:9",
version: "6.1",
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations"
payload := map[string]interface{}{
"prompt": "a beautiful sunset over mountains",
"size": "16:9",
"version": "6.1",
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations";
String payload = """
{
"prompt": "a beautiful sunset over mountains",
"size": "16:9",
"version": "6.1",
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations";
$payload = [
"prompt" => "a beautiful sunset over mountains",
"size" => "16:9",
"version" => "6.1",
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations")
payload = {
prompt: "a beautiful sunset over mountains",
size: "16:9",
version: "6.1",
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations")!
let payload: [String: Any] = [
"prompt": "a beautiful sunset over mountains",
"size": "16:9",
"version": "6.1",
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations";
var payload = @"{
""prompt"": ""a beautiful sunset over mountains"",
""size"": ""16:9"",
""version"": ""6.1"",
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations";
const char *payload = "{"
"\"prompt\":\"a beautiful sunset over mountains\","
"\"size\":\"16:9\","
"\"version\":\"6.1\","
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations"];
NSDictionary *payload = @{
@"prompt": @"a beautiful sunset over mountains",
@"size": @"16:9",
@"version": @"6.1",
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations"
let payload = {|{
"prompt": "a beautiful sunset over mountains",
"size": "16:9",
"version": "6.1",
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations');
final payload = {
'prompt': 'a beautiful sunset over mountains',
'size': '16:9',
'version': '6.1',
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations"
payload <- list(
prompt = "a beautiful sunset over mountains",
size = "16:9",
version = "6.1",
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 422 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}422 复制
{
"error": {
"code": 422,
"message": "图片或提示词未通过内容审核,已自动退款",
"type": "invalid_request_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Blend(多图融合)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
将 2–4 张图融合成一张新图(MJ 经典 blend),完全靠图融合,不支持 prompt
将 2–4 张图融合成一张新图(MJ 经典 blend 功能),完全靠图融合,不支持 prompt 参数 。
项目
内容
action
BLEND
计费
midjourney@blend[-speed]
必填
image_urls(2–4 张)
参数
字段
类型
必填
默认
说明
image_urls
string[]
是
—
垫图,2–4 张,后端自动转 base64;单图 ≤ 12 MiB
dimensions
string
否
SQUARE
三档画面比例:SQUARE(1:1) / PORTRAIT(2:3) / LANDSCAPE(3:2);传了 size 时被覆盖
size
string
否
—
自由比例,任意 w:h(如 "16:9"、"9:16"、"21:9"),优先级高于 dimensions ,作为画面比例生效
speed
string
否
relax
relax / fast / turbo
metadata
object
否
—
自定义元数据
请求示例
三档比例(dimensions):
{
"image_urls": [
"https://example.com/a.png",
"https://example.com/b.png"
],
"dimensions": "SQUARE",
"speed": "fast"
}
自由比例(size):
{
"image_urls": [
"https://example.com/a.png",
"https://example.com/b.png"
],
"size": "16:9",
"speed": "fast"
}
最终 prompt 末尾会带 --ar 16:9。
注意
比例选择优先级:size(自由) > dimensions(三档) > 默认 SQUARE。
image_urls 少于 2 张或多于 4 张返回 400。
blend 没有独立版本参数;如需区分速度价格,可配置 midjourney@blend-fast / midjourney@blend-turbo。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/blend \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"image_urls": [
"https://example.com/a.png",
"https://example.com/b.png"
],
"dimensions": "SQUARE",
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/blend"
payload = {
"image_urls": [
"https://example.com/a.png",
"https://example.com/b.png"
],
"dimensions": "SQUARE",
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/blend";
const payload = {
image_urls: [
"https://example.com/a.png",
"https://example.com/b.png"
],
dimensions: "SQUARE",
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/blend"
payload := map[string]interface{}{
"image_urls": []string{
"https://example.com/a.png",
"https://example.com/b.png",
},
"dimensions": "SQUARE",
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/blend";
String payload = """
{
"image_urls": [
"https://example.com/a.png",
"https://example.com/b.png"
],
"dimensions": "SQUARE",
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/blend";
$payload = [
"image_urls" => [
"https://example.com/a.png",
"https://example.com/b.png",
],
"dimensions" => "SQUARE",
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/blend")
payload = {
image_urls: [
"https://example.com/a.png",
"https://example.com/b.png",
],
dimensions: "SQUARE",
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/blend")!
let payload: [String: Any] = [
"image_urls": [
"https://example.com/a.png",
"https://example.com/b.png",
],
"dimensions": "SQUARE",
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/blend";
var payload = @"{
""image_urls"": [
""https://example.com/a.png"",
""https://example.com/b.png""
],
""dimensions"": ""SQUARE"",
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/blend";
const char *payload = "{"
"\"image_urls\":[\"https://example.com/a.png\",\"https://example.com/b.png\"],"
"\"dimensions\":\"SQUARE\","
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/blend"];
NSDictionary *payload = @{
@"image_urls": @[
@"https://example.com/a.png",
@"https://example.com/b.png",
],
@"dimensions": @"SQUARE",
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/blend"
let payload = {|{
"image_urls": [
"https://example.com/a.png",
"https://example.com/b.png"
],
"dimensions": "SQUARE",
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/blend');
final payload = {
'image_urls': [
'https://example.com/a.png',
'https://example.com/b.png',
],
'dimensions': 'SQUARE',
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/blend"
payload <- list(
image_urls = list(
"https://example.com/a.png",
"https://example.com/b.png"
),
dimensions = "SQUARE",
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 422 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}422 复制
{
"error": {
"code": 422,
"message": "图片或提示词未通过内容审核,已自动退款",
"type": "invalid_request_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Describe(图生文)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
图片反推 prompt,同步返回(1–3s),结果在 prompt / description 字段
图片反推 prompt。通常 1–3s 同步返回,但仍走平台标准异步流 ——提交后照常轮询查询。
项目
内容
action
DESCRIBE
计费
midjourney@describe[-speed]
必填
image_urls(1 张)
参数
字段
类型
必填
默认
说明
image_urls
string[]
是
—
单张图;数组形式,多传只取第一张;单图 ≤ 12 MiB
speed
string
否
relax
relax / fast / turbo
metadata
object
否
—
自定义元数据
请求示例
{
"image_urls": ["https://example.com/input.png"],
"speed": "fast"
}
响应
文字结果在查询结果的 prompt / description,不返回 image_urls / grid_image_url 。反推为 4 段带编号建议,用 \n 分隔、数字 emoji 1️⃣2️⃣3️⃣4️⃣ 前缀:
{
"id": "task_xxx",
"status": "SUCCESS",
"action": "DESCRIBE",
"mode": "DESCRIBE",
"prompt": "1️⃣ a serene mountain lake at sunrise --ar 3:2\n2️⃣ mountain landscape with reflections --v 6.1\n3️⃣ panoramic view of alpine lake --ar 16:9\n4️⃣ dawn light over still water --s 250",
"description": "1️⃣ a serene mountain lake at sunrise --ar 3:2\n..."
}
注意
describe 为独立处理通道,不占用普通生图的并发额度。
通常 1–3s 同步返回,但仍需轮询 GET /v1/tasks/{task_id}(或 GET /v1/midjourney/{task_id})拿结果。
缺图返回 400;单图超 12 MiB 返回 400。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/describe \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"image_urls": [
"https://example.com/input.png"
],
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/describe"
payload = {
"image_urls": [
"https://example.com/input.png"
],
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/describe";
const payload = {
image_urls: [
"https://example.com/input.png"
],
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/describe"
payload := map[string]interface{}{
"image_urls": []string{
"https://example.com/input.png",
},
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/describe";
String payload = """
{
"image_urls": [
"https://example.com/input.png"
],
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/describe";
$payload = [
"image_urls" => [
"https://example.com/input.png",
],
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/describe")
payload = {
image_urls: [
"https://example.com/input.png",
],
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/describe")!
let payload: [String: Any] = [
"image_urls": [
"https://example.com/input.png",
],
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/describe";
var payload = @"{
""image_urls"": [
""https://example.com/input.png""
],
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/describe";
const char *payload = "{"
"\"image_urls\":[\"https://example.com/input.png\"],"
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/describe"];
NSDictionary *payload = @{
@"image_urls": @[
@"https://example.com/input.png",
],
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/describe"
let payload = {|{
"image_urls": [
"https://example.com/input.png"
],
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/describe');
final payload = {
'image_urls': [
'https://example.com/input.png',
],
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/describe"
payload <- list(
image_urls = list(
"https://example.com/input.png"
),
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 422 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}422 复制
{
"error": {
"code": 422,
"message": "图片或提示词未通过内容审核,已自动退款",
"type": "invalid_request_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Edits(图片编辑)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
基于已有图 + prompt 改写整张图。适合背景替换、风格迁移、内容修改
基于已有图 + prompt 改写整张图 。适合背景替换、风格迁移、内容修改。
项目
内容
action
EDITS
计费
midjourney@edits[-speed]
必填
prompt + image_urls
参数
字段
类型
必填
默认
说明
prompt
string
是
—
编辑指令
image_urls
string[]
是
—
待编辑图;单图 ≤ 12 MiB
speed
string
否
relax
relax / fast / turbo
metadata
object
否
—
自定义元数据
结构化参数(可选)
同 Imagine ,可写在 body 里或 prompt 中(如 --ar 16:9),body 优先级高于 prompt,会拼到 prompt 末尾并覆盖同名手写 flag。
字段
类型
等价 MJ 参数
说明
size
string
--ar
宽高比,如 "16:9", "1:1", "9:16"
quality
string
--q
质量:"0.25", "0.5", "1", "2"
style
string
--style
风格:"raw" 等
version
string
--v
版本号。主版本会追加为 --v <version>;与 niji: true 搭配 "7" / "6" 时会归一化为 Niji 版本
seed
int
--seed
随机种子
negative_prompt
string
--no
负面提示词,如 "ugly, blurry"
stylize
int
--s
风格化强度 (0-1000)
chaos
int
--c
混乱度 (0-100)
weird
int
--w
怪异度 (0-3000)
tile
bool
--tile
平铺模式
niji
bool
--niji
Niji 开关。推荐传 niji: true + version: "7" / "6"
iw
float
--iw
图片权重 (0-3),垫图时使用
cw
int
--cw
角色权重 (0-100)
sw
int
--sw
风格权重 (0-1000)
cref
string
--cref
角色参考图 URL
sref
string
--sref
风格参考图 URL
dref
string
--dref
深度参考图 URL
dw
float
--dw
深度权重 (0-100)
repeat
int
--repeat
重复生成次数 (2-40)
raw
bool
--raw
原始风格 (v5.1+ 支持)
draft
bool
--draft
草图模式 (v7+ 支持)
hd
bool
--hd
HD 高清 (仅 v8.1 / v8.2,未传 version 时后端自动补 --v 8.1)
stop
int
--stop
提前停止 (10-100,仅 v5-6.1 / niji 5-6)
extra
string
任意 --xxx
逃生口,原样追加到 prompt 末尾
请求示例
{
"prompt": "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
"image_urls": ["https://example.com/product.png"],
"version": "8.1",
"speed": "fast"
}
响应
提交返回 task_id,SUCCESS 后含编辑结果 image_urls(可能 1–4 张)+ grid_image_url。
注意
与 imagine 垫图的区别:edits 重在"改写整张图",imagine + 垫图重在"参考风格"。
缺 prompt 或 image_urls 返回 400;单图超 12 MiB 返回 400。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/edits \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"prompt": "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
"image_urls": [
"https://example.com/product.png"
],
"version": "8.1",
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/edits"
payload = {
"prompt": "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
"image_urls": [
"https://example.com/product.png"
],
"version": "8.1",
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/edits";
const payload = {
prompt: "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
image_urls: [
"https://example.com/product.png"
],
version: "8.1",
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/edits"
payload := map[string]interface{}{
"prompt": "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
"image_urls": []string{
"https://example.com/product.png",
},
"version": "8.1",
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/edits";
String payload = """
{
"prompt": "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
"image_urls": [
"https://example.com/product.png"
],
"version": "8.1",
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/edits";
$payload = [
"prompt" => "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
"image_urls" => [
"https://example.com/product.png",
],
"version" => "8.1",
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/edits")
payload = {
prompt: "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
image_urls: [
"https://example.com/product.png",
],
version: "8.1",
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/edits")!
let payload: [String: Any] = [
"prompt": "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
"image_urls": [
"https://example.com/product.png",
],
"version": "8.1",
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/edits";
var payload = @"{
""prompt"": ""replace the background with a modern kitchen, keep the product unchanged --ar 1:1"",
""image_urls"": [
""https://example.com/product.png""
],
""version"": ""8.1"",
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/edits";
const char *payload = "{"
"\"prompt\":\"replace the background with a modern kitchen, keep the product unchanged --ar 1:1\","
"\"image_urls\":[\"https://example.com/product.png\"],"
"\"version\":\"8.1\","
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/edits"];
NSDictionary *payload = @{
@"prompt": @"replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
@"image_urls": @[
@"https://example.com/product.png",
],
@"version": @"8.1",
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/edits"
let payload = {|{
"prompt": "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
"image_urls": [
"https://example.com/product.png"
],
"version": "8.1",
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/edits');
final payload = {
'prompt': 'replace the background with a modern kitchen, keep the product unchanged --ar 1:1',
'image_urls': [
'https://example.com/product.png',
],
'version': '8.1',
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/edits"
payload <- list(
prompt = "replace the background with a modern kitchen, keep the product unchanged --ar 1:1",
image_urls = list(
"https://example.com/product.png"
),
version = "8.1",
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 422 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}422 复制
{
"error": {
"code": 422,
"message": "图片或提示词未通过内容审核,已自动退款",
"type": "invalid_request_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Upscale(放大选图)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
对 Imagine 四宫格选取 U1–U4 中的一张得到单图,本地合成、通常瞬时返回
对父任务四宫格(grid_image_url)选取 U1–U4 中的一张,得到单图。通过从已有 4 张图里截取 实现,本地合成、通常瞬时返回。
项目
内容
action
UPSCALE
计费
midjourney@upscale[-version][-speed]
必填
task_id + index,或 task_id + custom_id
可选
speed、metadata
参数
字段
类型
说明
task_id
string
父任务 ID(须为 imagine / variation / reroll 等 SUCCESS 任务)
index
int
选第几张(U1–U4),范围 1–4;与 custom_id 二选一
custom_id
string
直接传对应操作的按钮 ID;与 index 二选一,传了它就不按 index 匹配
speed
string
relax / fast / turbo(本地合成,实际无影响)
metadata
object
自定义元数据
请求示例
按 index 选图:
{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 1,
"speed": "fast"
}
直接传按钮:
{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"custom_id": "MJ::JOB::upsample::1::xxxx"
}
响应
提交返回新 task_id,通常毫秒级即 SUCCESS 。SUCCESS 后 image_urls 只有 1 个元素(单图),buttons 含可继续的操作(zoom / inpaint / pan / variation 等)。
注意
父任务必须是 SUCCESS 状态,否则返回 400(task is not in SUCCESS state)。
index 必须 1–4,越界返回 400;custom_id 与 index 二选一,都传时 custom_id 优先。
真正消耗资源的是 imagine 阶段,upscale 只是从已有图里挑,几乎不会失败。
upscale 后的单图可继续用 Zoom / Inpaint / Variation。
HD upscale(高清放大,输出 2x 单图)
普通 upscale 是本地合成 ——从父任务已有的 4 张图里截取其中一张,瞬时返回。如果后续要对单图做 zoom / inpaint 等精细操作,建议改用 HD upscale :执行真实放大,输出 2x 高清单图 ,约 60–120s 完成,产出的单图能更稳定地支持后续 zoom / inpaint。
HD upscale 通过 custom_id 指定放大命令,不同 imagine 版本对应不同命令:
customId 命令
适用版本
upsample_v5_2x
v5 imagine
upsample_v5_4x
v5 imagine
upsample_v6_2x_subtle
v6 / v6.1 imagine
upsample_v6_2x_creative
v6 / v6.1 imagine
upsample_v7_2x_subtle
v7 / v8.1 imagine
upsample_v7_2x_creative
v7 / v8.1 imagine
HD upscale 示例
{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"custom_id": "MJ::JOB::upsample_v7_2x_subtle::1::xxxx"
}
完成后得到一张真正的 2x 高清单图任务,可继续对它做 zoom / inpaint。
与普通 upscale 对比
维度
普通 upscale
HD upscale
实现
本地合成(截取)
真实放大处理
耗时
毫秒级
约 60–120s
输出
4 张里取第 N 张
2x 高清单图
后续
zoom / inpaint / variation
zoom / inpaint 更稳定
⚠️ pan 仍不可用
即使是 HD upscale 产出的高清单图,pan 操作仍会被拒 (返回"无效生图请求")——这是 Midjourney 对 pan 操作本身的限制,与放大方式无关。详见 Pan 。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/upscale \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 1,
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/upscale"
payload = {
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 1,
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/upscale";
const payload = {
task_id: "task_01KQVZAPBW13W63DQNQZT7FCQK",
index: 1,
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/upscale"
payload := map[string]interface{}{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 1,
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/upscale";
String payload = """
{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 1,
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/upscale";
$payload = [
"task_id" => "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index" => 1,
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/upscale")
payload = {
task_id: "task_01KQVZAPBW13W63DQNQZT7FCQK",
index: 1,
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/upscale")!
let payload: [String: Any] = [
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 1,
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/upscale";
var payload = @"{
""task_id"": ""task_01KQVZAPBW13W63DQNQZT7FCQK"",
""index"": 1,
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/upscale";
const char *payload = "{"
"\"task_id\":\"task_01KQVZAPBW13W63DQNQZT7FCQK\","
"\"index\":1,"
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/upscale"];
NSDictionary *payload = @{
@"task_id": @"task_01KQVZAPBW13W63DQNQZT7FCQK",
@"index": @1,
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/upscale"
let payload = {|{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 1,
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/upscale');
final payload = {
'task_id': 'task_01KQVZAPBW13W63DQNQZT7FCQK',
'index': 1,
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/upscale"
payload <- list(
task_id = "task_01KQVZAPBW13W63DQNQZT7FCQK",
index = 1,
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Variation(生成变体)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
对 Imagine 四宫格的某一张做弱变体(varySubtle,等价 V1–V4)
对 imagine 四宫格里的某一张做弱变体 (varySubtle,等价 V1–V4)。强变体见 High Variation 。
项目
内容
action
VARIATION
计费
midjourney@variation[-speed]
必填
task_id + index,或 task_id + custom_id
可选
speed、metadata
参数
字段
说明
task_id
本平台返回的原任务 ID(须为 SUCCESS)
index
1–4,对应 V1–V4;与 custom_id 二选一
custom_id
直接指定对应操作的按钮 ID,传了它就不按 index 自动匹配
speed
relax / fast / turbo
metadata
自定义元数据
请求示例
{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 3,
"speed": "turbo"
}
响应
提交返回新的本地 task_id,轮询 GET /v1/tasks/{task_id},SUCCESS 后含变体的新四宫格 grid_image_url + 4 张 image_urls:
{
"id": "task_xxx",
"status": "SUCCESS",
"action": "VARIATION",
"grid_image_url": "...",
"image_urls": ["...", "...", "...", "..."]
}
来源任务的 version / niji 会自动继承(影响计费 fallback);如需区分速度价格,可配置 midjourney@variation-fast / midjourney@variation-turbo。
注意
父任务必须是 SUCCESS 状态,否则返回 400(task is not in SUCCESS state)。
index 必须 1–4;custom_id 与 index 二选一。
默认走 varySubtle(弱变体);强变体用 High Variation ;Low Variation 是同 action 不同计费 key,行为相同。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/variation \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 3,
"speed": "turbo"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/variation"
payload = {
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 3,
"speed": "turbo"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/variation";
const payload = {
task_id: "task_01KQVZAPBW13W63DQNQZT7FCQK",
index: 3,
speed: "turbo"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/variation"
payload := map[string]interface{}{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 3,
"speed": "turbo",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/variation";
String payload = """
{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 3,
"speed": "turbo"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/variation";
$payload = [
"task_id" => "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index" => 3,
"speed" => "turbo",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/variation")
payload = {
task_id: "task_01KQVZAPBW13W63DQNQZT7FCQK",
index: 3,
speed: "turbo",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/variation")!
let payload: [String: Any] = [
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 3,
"speed": "turbo",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/variation";
var payload = @"{
""task_id"": ""task_01KQVZAPBW13W63DQNQZT7FCQK"",
""index"": 3,
""speed"": ""turbo""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/variation";
const char *payload = "{"
"\"task_id\":\"task_01KQVZAPBW13W63DQNQZT7FCQK\","
"\"index\":3,"
"\"speed\":\"turbo\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/variation"];
NSDictionary *payload = @{
@"task_id": @"task_01KQVZAPBW13W63DQNQZT7FCQK",
@"index": @3,
@"speed": @"turbo",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/variation"
let payload = {|{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"index": 3,
"speed": "turbo"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/variation');
final payload = {
'task_id': 'task_01KQVZAPBW13W63DQNQZT7FCQK',
'index': 3,
'speed': 'turbo',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/variation"
payload <- list(
task_id = "task_01KQVZAPBW13W63DQNQZT7FCQK",
index = 3,
speed = "turbo"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
High Variation(大幅变体)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
对已 upscale 的单图做强变体(varyStrong,对应 Vary (Strong))
对已 upscale 的单图做强变体 (varyStrong,对应 Vary (Strong),变化幅度大、偏离原图更多)。弱变体见 Variation 。
项目
内容
action
HIGH_VARIATION
计费
midjourney@high_variation[-speed]
必填
task_id + index,或 task_id + custom_id
可选
speed、metadata
参数
字段
说明
task_id
本平台返回的任务 ID(通常为 Upscale 后的单图任务)
index
1–4;未传 custom_id 时必填,按钮匹配不使用 index
custom_id
直接指定对应操作的按钮 ID;传入后不按 index 自动匹配
speed
relax / fast / turbo
metadata
可选,自定义元数据
自动匹配
优先匹配 Vary (Strong),失败回退 Make Variations。
请求示例
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}
注意
通常先对四宫格调用 upscale,再拿 upscale 产生的新 task_id 调用本接口。
当前实现中未传 custom_id 时仍要求 index,虽然按钮匹配本身不使用 index。
来源任务的版本 metadata 会自动继承;如需区分速度价格,可配置 midjourney@high_variation-fast / midjourney@high_variation-turbo。
返回
提交成功返回新的本地 task_id,请轮询 GET /v1/tasks/{task_id} 查询结果。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/high-variation \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation"
payload = {
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation";
const payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
index: 1,
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation"
payload := map[string]interface{}{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation";
String payload = """
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation";
$payload = [
"task_id" => "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index" => 1,
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/high-variation")
payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
index: 1,
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation")!
let payload: [String: Any] = [
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation";
var payload = @"{
""task_id"": ""task_01KQW0D3WJ2QYJP9E3H7GZ4D2R"",
""index"": 1,
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation";
const char *payload = "{"
"\"task_id\":\"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R\","
"\"index\":1,"
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/high-variation"];
NSDictionary *payload = @{
@"task_id": @"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
@"index": @1,
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation"
let payload = {|{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/high-variation');
final payload = {
'task_id': 'task_01KQW0D3WJ2QYJP9E3H7GZ4D2R',
'index': 1,
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/high-variation"
payload <- list(
task_id = "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
index = 1,
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Low Variation(微调变体)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
对已 upscale 的单图做弱变体(varySubtle,与 Variation 行为一致,仅计费 key 不同)
对已 upscale 的单图做弱变体 (varySubtle,与 Variation 行为完全一致)。独立 endpoint 主要用于命名一致性(与 High Variation 对偶)和价格独立配置;新接入推荐直接用 Variation 。
项目
内容
action
LOW_VARIATION
计费
midjourney@low_variation[-speed]
必填
task_id + index,或 task_id + custom_id
可选
speed、metadata
参数
字段
说明
task_id
本平台返回的任务 ID(通常为 Upscale 后的单图任务)
index
1–4;未传 custom_id 时必填,按钮匹配不使用 index
custom_id
直接指定对应操作的按钮 ID;传入后不按 index 自动匹配
speed
relax / fast / turbo
metadata
可选,自定义元数据
自动匹配
优先匹配 Vary (Subtle),失败回退 Make Variations。
请求示例
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}
注意
通常先对四宫格调用 upscale,再拿 upscale 产生的新 task_id 调用本接口。
当前实现中未传 custom_id 时仍要求 index,虽然按钮匹配本身不使用 index。
来源任务的版本 metadata 会自动继承;如需区分速度价格,可配置 midjourney@low_variation-fast / midjourney@low_variation-turbo。
返回
提交成功返回新的本地 task_id,请轮询 GET /v1/tasks/{task_id} 查询结果。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/low-variation \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation"
payload = {
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation";
const payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
index: 1,
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation"
payload := map[string]interface{}{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation";
String payload = """
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation";
$payload = [
"task_id" => "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index" => 1,
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/low-variation")
payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
index: 1,
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation")!
let payload: [String: Any] = [
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation";
var payload = @"{
""task_id"": ""task_01KQW0D3WJ2QYJP9E3H7GZ4D2R"",
""index"": 1,
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation";
const char *payload = "{"
"\"task_id\":\"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R\","
"\"index\":1,"
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/low-variation"];
NSDictionary *payload = @{
@"task_id": @"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
@"index": @1,
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation"
let payload = {|{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"index": 1,
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/low-variation');
final payload = {
'task_id': 'task_01KQW0D3WJ2QYJP9E3H7GZ4D2R',
'index': 1,
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/low-variation"
payload <- list(
task_id = "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
index = 1,
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Reroll(重新生成)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
基于父任务 prompt 重新抽 4 张图(等价 🔄 重抽按钮),整网格重抽无需 index
基于父任务的 prompt 重新抽 4 张图(等价 🔄 重抽按钮)。整个网格重抽,无需 index 。
项目
内容
action
REROLL
计费
midjourney@reroll[-speed]
必填
task_id,或 task_id + custom_id
可选
speed、metadata
参数
字段
说明
task_id
本平台返回的原任务 ID
custom_id
可选,直接指定 reroll 对应操作的按钮 ID
speed
relax / fast / turbo
metadata
可选,自定义元数据
自动匹配
服务端会从原任务 buttons 中匹配包含 ::reroll:: 的按钮,或匹配 reroll emoji。
请求示例
{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"speed": "fast"
}
错误响应
HTTP
code
description
400
4
task_id is required for reroll
400
4
task ... is not in SUCCESS state
404
3
task ... not found
502
9
服务拒绝
返回
提交成功返回新的本地 task_id,请轮询 GET /v1/tasks/{task_id},SUCCESS 后是同 prompt 的全新四宫格 。
来源任务的 prompt / version / niji / 结构化参数会自动继承(种子可能不同,因此结果不同);如需区分速度价格,可配置 midjourney@reroll-fast / midjourney@reroll-turbo。
注意
只能 reroll imagine 或自身 reroll 产生的网格任务;不能 reroll 已做过 upscale / variation / pan 等二次操作的任务 。
父任务必须是 SUCCESS 状态。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/reroll \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/reroll"
payload = {
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/reroll";
const payload = {
task_id: "task_01KQVZAPBW13W63DQNQZT7FCQK",
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/reroll"
payload := map[string]interface{}{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/reroll";
String payload = """
{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/reroll";
$payload = [
"task_id" => "task_01KQVZAPBW13W63DQNQZT7FCQK",
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/reroll")
payload = {
task_id: "task_01KQVZAPBW13W63DQNQZT7FCQK",
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/reroll")!
let payload: [String: Any] = [
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/reroll";
var payload = @"{
""task_id"": ""task_01KQVZAPBW13W63DQNQZT7FCQK"",
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/reroll";
const char *payload = "{"
"\"task_id\":\"task_01KQVZAPBW13W63DQNQZT7FCQK\","
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/reroll"];
NSDictionary *payload = @{
@"task_id": @"task_01KQVZAPBW13W63DQNQZT7FCQK",
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/reroll"
let payload = {|{
"task_id": "task_01KQVZAPBW13W63DQNQZT7FCQK",
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/reroll');
final payload = {
'task_id': 'task_01KQVZAPBW13W63DQNQZT7FCQK',
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/reroll"
payload <- list(
task_id = "task_01KQVZAPBW13W63DQNQZT7FCQK",
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Zoom(缩放扩展)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
对已 upscale 的单图执行 Zoom Out 扩图,原图保留向外补背景(Outpaint / CustomZoom)
对已 upscale 的单图执行 Zoom Out(扩图缩放):原图保留,向外补充更多背景。zoom_ratio < 2 走 Outpaint(1.5×),≥ 2 或未传走 CustomZoom(2×),两者均直接出图。
项目
内容
action
ZOOM
计费
midjourney@zoom[-speed]
必填
task_id,或 task_id + custom_id
可选
zoom_ratio、index、speed、metadata
参数
字段
说明
task_id
本平台返回的任务 ID(须为 Upscale 后的单图任务)
custom_id
可选,直接指定 Zoom 对应操作的按钮 ID
index
可选,选父任务第几张(1–4,默认 1);单图通常不用动
zoom_ratio
可选,决定自动匹配的 Zoom Out 档位(见下表)
speed
relax / fast / turbo
metadata
可选
自动匹配
zoom_ratio
匹配按钮
小于 2
Zoom Out 1.5x
未传或 >= 2
Zoom Out 2x
请求示例
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"zoom_ratio": 1.5,
"speed": "fast"
}
注意
父任务必须是已 upscale 的单图 且为 SUCCESS;传四宫格会返回 This action requires an upscaled task...,需先调用 upscale。
Outpaint / CustomZoom 均直接出图,无需 mask,不进 MODAL (只有 Inpaint 走 MODAL)。
来源任务的版本 metadata 会自动继承;如需区分速度价格,可配置 midjourney@zoom-fast / midjourney@zoom-turbo。
返回
提交成功返回新的本地 task_id,请轮询 GET /v1/tasks/{task_id} 查询结果。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/zoom \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"zoom_ratio": 1.5,
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/zoom"
payload = {
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"zoom_ratio": 1.5,
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/zoom";
const payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
zoom_ratio: 1.5,
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/zoom"
payload := map[string]interface{}{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"zoom_ratio": 1.5,
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/zoom";
String payload = """
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"zoom_ratio": 1.5,
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/zoom";
$payload = [
"task_id" => "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"zoom_ratio" => 1.5,
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/zoom")
payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
zoom_ratio: 1.5,
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/zoom")!
let payload: [String: Any] = [
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"zoom_ratio": 1.5,
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/zoom";
var payload = @"{
""task_id"": ""task_01KQW0D3WJ2QYJP9E3H7GZ4D2R"",
""zoom_ratio"": 1.5,
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/zoom";
const char *payload = "{"
"\"task_id\":\"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R\","
"\"zoom_ratio\":1.5,"
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/zoom"];
NSDictionary *payload = @{
@"task_id": @"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
@"zoom_ratio": @1.5,
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/zoom"
let payload = {|{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"zoom_ratio": 1.5,
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/zoom');
final payload = {
'task_id': 'task_01KQW0D3WJ2QYJP9E3H7GZ4D2R',
'zoom_ratio': 1.5,
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/zoom"
payload <- list(
task_id = "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
zoom_ratio = 1.5,
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Pan(平移扩展)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
对已 upscale 的单图向指定方向接图扩展,可连续 pan 拼全景(仅 v6/v6.1/v7/v8.1/v8.2/niji6)
对已 upscale 的单图向指定方向"接图"扩展:原图保留在边缘,新方向区域补全。可连续 pan(向右后继续向右),适合拼全景图。
项目
内容
action
PAN
计费
midjourney@pan[-speed]
必填
task_id + direction,或 task_id + custom_id
可选
index、speed、metadata
参数
字段
说明
task_id
本平台返回的任务 ID(须为 Upscale 后的单图任务)
direction
left / right / up / down
custom_id
可选,直接指定 Pan 对应操作的按钮 ID;指定后不必再传 direction
index
可选(1–4),backend 自动转 0-based
speed
relax / fast / turbo
metadata
可选
自动匹配按 customId 子串:pan_left、pan_right、pan_up、pan_down。
请求示例
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"direction": "right",
"speed": "fast"
}
注意
版本限制 :pan 仅适用于 v6 / v6.1 / v7 / v8.1 / v8.2 / niji 6 ;v5.2 及更早会 FAILURE(MJ engine 跑不出)。
如果返回 This action requires an upscaled task...,说明传入的是四宫格任务,需要先调用 upscale。
direction 必须是 left / right / up / down 之一。
来源任务的版本 metadata 会自动继承;如需区分速度价格,可配置 midjourney@pan-fast / midjourney@pan-turbo。
返回
提交成功返回新的本地 task_id,请轮询 GET /v1/tasks/{task_id} 查询结果。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/pan \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"direction": "right",
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/pan"
payload = {
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"direction": "right",
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/pan";
const payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
direction: "right",
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/pan"
payload := map[string]interface{}{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"direction": "right",
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/pan";
String payload = """
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"direction": "right",
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/pan";
$payload = [
"task_id" => "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"direction" => "right",
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/pan")
payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
direction: "right",
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/pan")!
let payload: [String: Any] = [
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"direction": "right",
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/pan";
var payload = @"{
""task_id"": ""task_01KQW0D3WJ2QYJP9E3H7GZ4D2R"",
""direction"": ""right"",
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/pan";
const char *payload = "{"
"\"task_id\":\"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R\","
"\"direction\":\"right\","
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/pan"];
NSDictionary *payload = @{
@"task_id": @"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
@"direction": @"right",
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/pan"
let payload = {|{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"direction": "right",
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/pan');
final payload = {
'task_id': 'task_01KQW0D3WJ2QYJP9E3H7GZ4D2R',
'direction': 'right',
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/pan"
payload <- list(
task_id = "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
direction = "right",
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Inpaint(局部重绘)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
局部重绘入口(等价 Vary (Region)),提交后进 MODAL,需再调 modal 上传 mask + prompt
局部重绘入口(等价 Vary (Region))。提交后任务进 MODAL 状态 ,需再调 modal 上传 mask + prompt 才能完成。
项目
内容
action
INPAINT
计费
midjourney@inpaint[-version][-speed]
必填
task_id,或 task_id + custom_id
可选
index、speed、metadata
参数
字段
说明
task_id
原任务 ID(一般为 Upscale 后的单图任务)
custom_id
可选,直接指定 Vary (Region) 对应操作的按钮 ID
index
可选,选父任务第几张(1–4,默认 1);单图通常不用动
speed
relax / fast / turbo
metadata
可选
自动匹配
服务端从原任务 buttons 中匹配 Vary (Region)。
请求示例
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"speed": "fast"
}
后续流程
提交成功后返回 status: "modal"——这是合法非终态 ,不是错误。请用 modal 接口继续:其中 task_id 为上一步 inpaint 返回的本地任务 ID ,并提交 prompt 以及可选 mask_url 。
{
"task_id": "task_03_inpaint...",
"status": "modal",
"model": "midjourney"
}
注意
父任务必须是 SUCCESS 的 upscale 单图 ;四宫格直接 inpaint 会报错,需先 upscale。
进入 MODAL 后 30 分钟内必须调 modal 补参 ,否则后台自动 CANCEL + 退款。
来源任务的版本 metadata 会自动继承;如需区分速度价格,可配置 midjourney@inpaint-fast / midjourney@inpaint-turbo。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/inpaint \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint"
payload = {
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint";
const payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint"
payload := map[string]interface{}{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint";
String payload = """
{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint";
$payload = [
"task_id" => "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/inpaint")
payload = {
task_id: "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint")!
let payload: [String: Any] = [
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint";
var payload = @"{
""task_id"": ""task_01KQW0D3WJ2QYJP9E3H7GZ4D2R"",
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint";
const char *payload = "{"
"\"task_id\":\"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R\","
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/inpaint"];
NSDictionary *payload = @{
@"task_id": @"task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint"
let payload = {|{
"task_id": "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/inpaint');
final payload = {
'task_id': 'task_01KQW0D3WJ2QYJP9E3H7GZ4D2R',
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/inpaint"
payload <- list(
task_id = "task_01KQW0D3WJ2QYJP9E3H7GZ4D2R",
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 422 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}422 复制
{
"error": {
"code": 422,
"message": "图片或提示词未通过内容审核,已自动退款",
"type": "invalid_request_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Modal(提交补充参数)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
给 MODAL 状态的局部重绘任务补充 mask + prompt 完成重绘
给 MODAL 状态的局部重绘任务补充 mask + prompt 完成重绘。系统按 mask_url 是否存在自动判断模式:有 mask_url → 局部重绘;无 → 外扩 。
项目
内容
action
MODAL
计费
midjourney@modal[-speed]
必填
task_id
可选
prompt、mask_url、speed、metadata
参数
字段
说明
task_id
inpaint 步骤返回的本地任务 ID(须为 MODAL 状态)
prompt
局部重绘提示词;留空则继承父任务 prompt
mask_url
遮罩图 URL 或 base64;局部重绘时必填 。透明区域=要重绘的位置,白色区域=保留原图
speed
relax / fast / turbo
metadata
可选
mask 要求
项
建议
格式
PNG 透明背景(也支持 data:image/png;base64,...)
分辨率
建议与父图同分辨率(系统也会自动 resize)
透明区域
要重绘的位置;白色区域保留原图
大小
单图 ≤ 12 MiB
URL
必须公网可达(私网会被 SSRF 拦截)
请求示例
{
"task_id": "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
"prompt": "replace the selected area with a red leather sofa",
"mask_url": "https://example.com/mask.png",
"speed": "fast"
}
返回
task_id 不变(同一任务),status 从 MODAL → SUBMITTED。轮询 GET /v1/tasks/{task_id},SUCCESS 后 image_urls 含 4 张局部重绘候选。计费在本接口 SUCCESS 时结算,与 inpaint 阶段不重复扣费。
如需区分速度价格,可配置 midjourney@modal-fast / midjourney@modal-turbo。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/modal \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
"prompt": "replace the selected area with a red leather sofa",
"mask_url": "https://example.com/mask.png",
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/modal"
payload = {
"task_id": "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
"prompt": "replace the selected area with a red leather sofa",
"mask_url": "https://example.com/mask.png",
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/modal";
const payload = {
task_id: "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
prompt: "replace the selected area with a red leather sofa",
mask_url: "https://example.com/mask.png",
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/modal"
payload := map[string]interface{}{
"task_id": "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
"prompt": "replace the selected area with a red leather sofa",
"mask_url": "https://example.com/mask.png",
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/modal";
String payload = """
{
"task_id": "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
"prompt": "replace the selected area with a red leather sofa",
"mask_url": "https://example.com/mask.png",
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/modal";
$payload = [
"task_id" => "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
"prompt" => "replace the selected area with a red leather sofa",
"mask_url" => "https://example.com/mask.png",
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/modal")
payload = {
task_id: "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
prompt: "replace the selected area with a red leather sofa",
mask_url: "https://example.com/mask.png",
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/modal")!
let payload: [String: Any] = [
"task_id": "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
"prompt": "replace the selected area with a red leather sofa",
"mask_url": "https://example.com/mask.png",
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/modal";
var payload = @"{
""task_id"": ""task_01KQW1N9T6E3AHW6QZFDEK8M5C"",
""prompt"": ""replace the selected area with a red leather sofa"",
""mask_url"": ""https://example.com/mask.png"",
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/modal";
const char *payload = "{"
"\"task_id\":\"task_01KQW1N9T6E3AHW6QZFDEK8M5C\","
"\"prompt\":\"replace the selected area with a red leather sofa\","
"\"mask_url\":\"https://example.com/mask.png\","
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/modal"];
NSDictionary *payload = @{
@"task_id": @"task_01KQW1N9T6E3AHW6QZFDEK8M5C",
@"prompt": @"replace the selected area with a red leather sofa",
@"mask_url": @"https://example.com/mask.png",
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/modal"
let payload = {|{
"task_id": "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
"prompt": "replace the selected area with a red leather sofa",
"mask_url": "https://example.com/mask.png",
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/modal');
final payload = {
'task_id': 'task_01KQW1N9T6E3AHW6QZFDEK8M5C',
'prompt': 'replace the selected area with a red leather sofa',
'mask_url': 'https://example.com/mask.png',
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/modal"
payload <- list(
task_id = "task_01KQW1N9T6E3AHW6QZFDEK8M5C",
prompt = "replace the selected area with a red leather sofa",
mask_url = "https://example.com/mask.png",
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 422 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}422 复制
{
"error": {
"code": 422,
"message": "图片或提示词未通过内容审核,已自动退款",
"type": "invalid_request_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Video(图生视频)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
Midjourney 图生视频(i2v),固定 FAST,不支持 t2v,时长约 5 秒
图生视频(i2v)。固定 FAST 模式,无 speed 维度 ;不支持纯文生视频(t2v) ,必须给首帧。时长固定约 5 秒。
项目
内容
action
VIDEO
计费
midjourney@video / midjourney@video-720p,实扣 = 单价 × batch_size
必填
image_urls(首帧)或 task_id(复用 imagine SUCCESS)
参数
字段
类型
必填
默认
说明
prompt
string
否
(继承父任务)
视频提示词;为空时必须有 task_id
image_urls
string[]
△
—
起始帧(1 张,≤ 12 MiB);与 task_id 二选一
task_id
string
△
—
复用已有 imagine SUCCESS;与 image_urls 二选一
index
int
否
—
从 imagine 4 张图选哪张作首帧(0–3,配合 task_id)
video_type
string
否
vid_1.1_i2v_480
分辨率档(见下表);含 720 → 走 @video-720p 计费
animate_mode
string
否
manual
manual / auto;auto 必须给 task_id + index
motion
string
否
high
low / high;运动幅度,不影响计费
batch_size
int
否
1
必须 1 / 2 / 4,其他值视为 1;计费 × N
end_url
string
否
—
结束帧;设了后 video_type 自动升级为 start_end_*
video_type 合法值
值
分辨率
模式
命中价格
vid_1.1_i2v_480
480p
基础 i2v(默认)
midjourney@video
vid_1.1_i2v_720
720p
基础 i2v
midjourney@video-720p
vid_1.1_i2v_start_end_480
480p
起止帧(传 end_url 时自动升级)
midjourney@video
vid_1.1_i2v_start_end_720
720p
起止帧(传 end_url 时自动升级)
midjourney@video-720p
不接受带 extend 的取值;仅支持上表列出的 video_type。
请求示例
简单 i2v(自带首帧,batch 4):
{
"prompt": "the cat slowly turns its head to the camera",
"image_urls": ["https://example.com/cat.png"],
"motion": "high",
"batch_size": 4
}
起止帧 transition(传 end_url 自动升级为 start_end):
{
"prompt": "transition smoothly from sunrise to sunset",
"image_urls": ["https://example.com/sunrise.jpg"],
"end_url": "https://example.com/sunset.jpg",
"video_type": "vid_1.1_i2v_720"
}
响应
提交返回 task_id,轮询 GET /v1/tasks/{task_id}。SUCCESS 后含 video_url(首个)+ video_urls(length === batch_size,batch=1 时也是 1 个元素):
{
"id": "task_xxx",
"status": "SUCCESS",
"action": "VIDEO",
"mode": "FAST",
"video_url": "https://r2.example.com/video-0.mp4",
"video_urls": [
"https://r2.example.com/video-0.mp4",
"https://r2.example.com/video-1.mp4"
]
}
注意
不支持纯文生视频(t2v) :必须给 image_urls 或 task_id,否则返回 400;两者不能同时传。
固定 FAST 模式 ,无 speed 维度(计费表里 @video-fast / @video-turbo 永不命中)。
batch_size 严格校验为 1 / 2 / 4;batch=4 实扣 4 倍,预算敏感时用 batch=1 。
animate_mode=auto 必须同时给 task_id + index。
首帧 / 结束帧单图 ≤ 12 MiB。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/video \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"prompt": "the cat slowly turns its head to the camera",
"image_urls": [
"https://example.com/cat.png"
],
"motion": "high",
"batch_size": 4
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/video"
payload = {
"prompt": "the cat slowly turns its head to the camera",
"image_urls": [
"https://example.com/cat.png"
],
"motion": "high",
"batch_size": 4
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/video";
const payload = {
prompt: "the cat slowly turns its head to the camera",
image_urls: [
"https://example.com/cat.png"
],
motion: "high",
batch_size: 4
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/video"
payload := map[string]interface{}{
"prompt": "the cat slowly turns its head to the camera",
"image_urls": []string{
"https://example.com/cat.png",
},
"motion": "high",
"batch_size": 4,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/video";
String payload = """
{
"prompt": "the cat slowly turns its head to the camera",
"image_urls": [
"https://example.com/cat.png"
],
"motion": "high",
"batch_size": 4
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/video";
$payload = [
"prompt" => "the cat slowly turns its head to the camera",
"image_urls" => [
"https://example.com/cat.png",
],
"motion" => "high",
"batch_size" => 4,
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/video")
payload = {
prompt: "the cat slowly turns its head to the camera",
image_urls: [
"https://example.com/cat.png",
],
motion: "high",
batch_size: 4,
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/video")!
let payload: [String: Any] = [
"prompt": "the cat slowly turns its head to the camera",
"image_urls": [
"https://example.com/cat.png",
],
"motion": "high",
"batch_size": 4,
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/video";
var payload = @"{
""prompt"": ""the cat slowly turns its head to the camera"",
""image_urls"": [
""https://example.com/cat.png""
],
""motion"": ""high"",
""batch_size"": 4
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/video";
const char *payload = "{"
"\"prompt\":\"the cat slowly turns its head to the camera\","
"\"image_urls\":[\"https://example.com/cat.png\"],"
"\"motion\":\"high\","
"\"batch_size\":4"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/video"];
NSDictionary *payload = @{
@"prompt": @"the cat slowly turns its head to the camera",
@"image_urls": @[
@"https://example.com/cat.png",
],
@"motion": @"high",
@"batch_size": @4,
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/video"
let payload = {|{
"prompt": "the cat slowly turns its head to the camera",
"image_urls": [
"https://example.com/cat.png"
],
"motion": "high",
"batch_size": 4
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/video');
final payload = {
'prompt': 'the cat slowly turns its head to the camera',
'image_urls': [
'https://example.com/cat.png',
],
'motion': 'high',
'batch_size': 4,
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/video"
payload <- list(
prompt = "the cat slowly turns its head to the camera",
image_urls = list(
"https://example.com/cat.png"
),
motion = "high",
batch_size = 4
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 422 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}422 复制
{
"error": {
"code": 422,
"message": "图片或提示词未通过内容审核,已自动退款",
"type": "invalid_request_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Remix(重塑,仅 v8.1 / v8.2)
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
v8 操作面板的重塑(reshape),把父图重新生成可改 prompt,分强 / 弱两档
v8 操作面板新增的"重塑"(reshape):把父图重新生成,可改 prompt。仅 v8.1 / v8.2 父任务可用 ;v7 / v6 父图请改用 Variation / High Variation 。
POST /v1/midjourney/generations/remix-strong
POST /v1/midjourney/generations/remix-subtle
v8 操作面板移除了 U1-U4 / zoom / outpaint / inpaint。对应替代:变化 → Variation / High Variation;重塑 → 本接口;重新生成 → Reroll。
项目
内容
action
REMIX_STRONG / REMIX_SUBTLE
计费
midjourney@remix_strong[-speed] / midjourney@remix_subtle[-speed]
必填
task_id + index
参数
字段
类型
必填
默认
说明
task_id
string
是
—
父任务(v8.1 / v8.2 imagine SUCCESS )
index
int
是
—
选父图第几张做重塑(1–4)
prompt
string
否
(继承父任务)
重塑用的新 prompt;空则用父图 prompt
speed
string
否
relax
relax / fast / turbo
力度对比
接口
op
改动幅度
类比
/remix-strong
remixStrong
大幅改动,构图 / 风格都可能变
类似 High Variation(强变体)
/remix-subtle
remixSubtle
小幅改动,保持主体 / 色调
类似 Variation(弱变体)
请求示例
强烈重塑:
{
"task_id": "task_<v8_imagine_id>",
"index": 1,
"speed": "fast"
}
自定义 prompt 透传生效,可改风格 / 添加细节。
响应
提交返回新的本地 task_id,轮询 GET /v1/tasks/{task_id},SUCCESS 后含 4 张重塑图。
注意
仅 v8.1 / v8.2 父图可用 ;父任务非 v8 系列返回 400。
v7 / v6 父图请用 Variation / High Variation / Low Variation。
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"task_id": "task_<v8_imagine_id>",
"index": 1,
"speed": "fast"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong"
payload = {
"task_id": "task_<v8_imagine_id>",
"index": 1,
"speed": "fast"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong";
const payload = {
task_id: "task_<v8_imagine_id>",
index: 1,
speed: "fast"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong"
payload := map[string]interface{}{
"task_id": "task_<v8_imagine_id>",
"index": 1,
"speed": "fast",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong";
String payload = """
{
"task_id": "task_<v8_imagine_id>",
"index": 1,
"speed": "fast"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong";
$payload = [
"task_id" => "task_<v8_imagine_id>",
"index" => 1,
"speed" => "fast",
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong")
payload = {
task_id: "task_<v8_imagine_id>",
index: 1,
speed: "fast",
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong")!
let payload: [String: Any] = [
"task_id": "task_<v8_imagine_id>",
"index": 1,
"speed": "fast",
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong";
var payload = @"{
""task_id"": ""task_<v8_imagine_id>"",
""index"": 1,
""speed"": ""fast""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong";
const char *payload = "{"
"\"task_id\":\"task_<v8_imagine_id>\","
"\"index\":1,"
"\"speed\":\"fast\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong"];
NSDictionary *payload = @{
@"task_id": @"task_<v8_imagine_id>",
@"index": @1,
@"speed": @"fast",
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong"
let payload = {|{
"task_id": "task_<v8_imagine_id>",
"index": 1,
"speed": "fast"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong');
final payload = {
'task_id': 'task_<v8_imagine_id>',
'index': 1,
'speed': 'fast',
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/midjourney/generations/remix-strong"
payload <- list(
task_id = "task_<v8_imagine_id>",
index = 1,
speed = "fast"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 404 422 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KV52C0TEJSYZMCG0NCS4YWKK"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}422 复制
{
"error": {
"code": 422,
"message": "图片或提示词未通过内容审核,已自动退款",
"type": "invalid_request_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
任务查询
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
查询 Midjourney 任务状态与结果。统一任务接口 /v1/tasks/{task_id} 与 MJ 风格接口 /v1/midjourney/{task_id}
推荐业务侧轮询统一任务接口:
GET /v1/tasks/{task_id}
统一任务状态为 pending / processing / completed / failed,成功结果位于 result.images[].url。
需要读取 buttons[].customId 做二次操作时,使用 MJ 风格查询:
GET /v1/midjourney/{task_id}
任务状态流转
SUBMITTED → IN_PROGRESS → SUCCESS
→ FAILURE
→ MODAL(需补充参数,见局部重绘)
响应示例
{
"id": "task_01JWXXXX",
"status": "SUCCESS",
"action": "IMAGINE",
"progress": "100%",
"grid_image_url": "https://cdn.example.com/mj_xxxx.png",
"image_urls": [
"https://cdn.example.com/mj_xxxx_0.png",
"https://cdn.example.com/mj_xxxx_1.png",
"https://cdn.example.com/mj_xxxx_2.png",
"https://cdn.example.com/mj_xxxx_3.png"
],
"buttons": [
{"customId": "MJ::JOB::upsample::1::abc123def456", "label": "U1"},
{"customId": "MJ::JOB::variation::1::abc123def456", "label": "V1"}
],
"prompt": "a beautiful sunset over mountains"
}
grid_image_url 是四宫格合成大图,image_urls 是裁剪后的 4 张单图 URL 数组。
字段差异提醒
/v1/tasks/{task_id} 返回统一 pending / processing / completed / failed 状态。
/v1/midjourney/{task_id} 返回 MJ 风格字段,如 grid_image_url、image_urls、buttons。
关于 buttons: 大部分二次操作可传 index、direction 或 zoom_ratio,系统会自动匹配对应 customId;如自动匹配失败,可直接传 custom_id。
状态字段总览
status
含义
终态
NOT_START
已建行,系统未确认(瞬时态)
否
SUBMITTED
系统接受,排队中
否
IN_PROGRESS
系统处理中
否
MODAL
等待调 /modal 补参(见局部重绘)
否
SUCCESS
完成
✓
FAILURE
失败 → 自动退款(quota 归 0,fail_reason 含原因)
✓
查询说明
查询接口不单独计费 ,但建议合理控制频率(推荐 3–5s 轮询一次)。
普通用户只能查自己的任务;查他人任务返回 403。
任务默认保留 3 天 ,过后查询返回 404,但生成的图片 / 视频 URL 仍可访问 。
高级:使用 custom_id 直接操作
读取 buttons[].customId 后,可直接传给二次操作接口的 custom_id 字段,绕过自动匹配:
{
"task_id": "task_01JWXXXX",
"custom_id": "MJ::JOB::upsample::1::abc123def456"
}
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl --request GET \
--url https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK \
--header 'Authorization: Bearer <token>'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK"
headers = {
"Authorization": "Bearer <token>"
}
response = requests.get(url, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK";
const headers = {
"Authorization": "Bearer <token>"
};
fetch(url, {
method: "GET",
headers: headers
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer <token>")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.GET()
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK";
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer <token>"
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var response = await client.GetAsync(url);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK"];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"GET"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK"
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
in
let response = Client.get ~headers (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK');
final response = await http.get(
url,
headers: {
'Authorization': 'Bearer <token>',
},
);
print(response.body);
}R 复制
library(httr)
url <- "https://api.zhaotutu.ai/v1/midjourney/task_01KV52C0TEJSYZMCG0NCS4YWKK"
response <- GET(
url,
add_headers(
Authorization = "Bearer <token>"
)
)
cat(content(response, "text"))
Response
200 401 403 404 429 500 502
200 复制
{
"id": "task_01KV52C0TEJSYZMCG0NCS4YWKK",
"status": "SUCCESS",
"action": "IMAGINE",
"progress": "100%",
"grid_image_url": "https://cdn.example.com/mj_xxxx.png",
"image_urls": [
"https://cdn.example.com/mj_xxxx_0.png",
"https://cdn.example.com/mj_xxxx_1.png",
"https://cdn.example.com/mj_xxxx_2.png",
"https://cdn.example.com/mj_xxxx_3.png"
],
"buttons": [
{"customId": "MJ::JOB::upsample::1::abc123def456", "label": "U1"},
{"customId": "MJ::JOB::variation::1::abc123def456", "label": "V1"}
],
"prompt": "a beautiful sunset over mountains"
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}404 复制
{
"error": {
"code": 404,
"message": "任务不存在",
"type": "not_found_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
最佳实践
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
Midjourney 接入的轮询模式、Prompt 设计、垫图、错误重试策略、并发与排错建议
整合常见问题、性能优化、错误处理的最佳实践,接入前建议通读 。
任务提交与轮询
提交接口都是异步任务:提交后返回 task_id,再周期性查询 GET /v1/midjourney/{task_id} 拿状态,直到 SUCCESS / FAILURE。
import time, httpx
def wait_task(task_id, timeout=300):
deadline = time.time() + timeout
while time.time() < deadline:
resp = httpx.get(f"{HOST}/v1/midjourney/{task_id}",
headers={"Authorization": f"Bearer {API_KEY}"}).json()
if resp["status"] in ("SUCCESS", "FAILURE"):
return resp
if resp["status"] == "MODAL":
raise RuntimeError(f"task {task_id} 需要调 /modal 补参完成")
time.sleep(3)
raise TimeoutError(task_id)
轮询节奏 :建议 3–5s 一次,更高频无意义且浪费配额。
不要在 web 请求里同步阻塞 等任务完成 —— 提交后立即返回 task_id,让前端异步轮询。
Prompt 设计
好的 prompt:
a serene mountain lake at sunrise, photorealistic, soft golden light,
mist rising from water, snow-capped peaks in distance --ar 16:9 --v 8.1 --s 100
主体在前 :先主体,再描述场景,最后修饰词。
结构化参数显式 :用 --ar / --v / --s(或对应 body 字段)比依赖默认值更可控。
避免歧义词 :photorealistic 比 realistic 更明确。
避免: 过于抽象("make it good")、主体散乱(多个并列对象不分主次)、给词加引号(会被当字面值)。
Niji 动漫: 传 niji: true + version: "7",平台归一化为 --niji 7,计费走 midjourney@imagine-niji7。
垫图最佳实践
来源
推荐做法
注意
用户上传
先存自己的 OSS / CDN,提交时传该 URL
不要直接传 base64(浪费带宽)
公开 URL
直接传
注意 SSRF(须公网可达)与 12 MiB 限制
第三方 / 其他产物
先转存到自己的 OSS
第三方 URL 可能过期
压缩到 \< 5 MiB :平台上限 12 MiB,但小图传输 / 处理都更快。
格式 PNG / JPG / WebP 均可,推荐高质量 JPG。
分辨率 1024–2048 px 已足够,更高浪费。
垫图权重 iw(0–3,默认 1):>1 更贴原图,\<1 更自由。
错误处理与重试策略
code
含义
重试策略
1 / 200
成功
✅
4 VALIDATION_ERROR
参数错
❌ 不要重试,修正参数
3 NOT_FOUND
无可用实例 / task_id 不存在
实例不可用可稍后重试;task_id 不存在不要重试
9 FAILURE
服务拒绝 / 内部错误
⏳ 可重试,指数退避(1s, 4s, 16s)
21 MODAL
非终态
✅ 继续调 /modal
24 BANNED_PROMPT
敏感词
❌ 不要重试,改 prompt;已自动退款
429
限流
⏳ 指数退避 + jitter
5xx / 网络错
服务端 / 网络
⏳ 指数退避,网络错可立即重试 1 次
import time, random, httpx
def submit_with_retry(payload, max_attempts=5):
for attempt in range(max_attempts):
try:
r = httpx.post(f"{HOST}/v1/midjourney/generations/imagine",
json=payload,
headers={"Authorization": f"Bearer {API_KEY}"},
timeout=30)
data = r.json()
if r.status_code == 200 and data["code"] in (1, 200):
return data
if data["code"] in (4, 24):
raise ValueError(data["description"]) # 不可重试
if data["code"] == 3 and "task" in data["description"]:
raise ValueError(data["description"]) # task_id 不存在
# 其余(9 / 429 / 5xx)可重试
except httpx.RequestError:
pass
time.sleep((4 ** attempt) + random.uniform(0, 1)) # 1s / 4s / 16s ...
raise RuntimeError(f"达到最大重试次数 {max_attempts}")
二次操作流程
# imagine → 轮询 → upscale
imagine_id = submit({"prompt": "a cat"})["data"][0]["task_id"]
result = wait_task(imagine_id) # grid_image_url + 4 张 image_urls + buttons
upscale_id = submit_to("/upscale", {"task_id": imagine_id, "index": 2})["data"][0]["task_id"]
final = wait_task(upscale_id) # upscale 本地合成,1–2s
single_image = final["image_urls"][0]
局部重绘(inpaint → modal 两步):
imagine_id = submit({"prompt": "a portrait"})["data"][0]["task_id"]; wait_task(imagine_id)
upscale_id = submit_to("/upscale", {"task_id": imagine_id, "index": 1})["data"][0]["task_id"]; wait_task(upscale_id)
inpaint_id = submit_to("/inpaint", {"task_id": upscale_id})["data"][0]["task_id"] # status=modal
# 前端画 mask(透明=重绘区),上传到自己的 OSS 拿 mask_url
final = submit_to("/modal", {
"task_id": inpaint_id,
"prompt": "replace the eyes with cybernetic blue eyes",
"mask_url": "https://your-oss.com/mask.png"
})
wait_task(final["data"][0]["task_id"])
⚠️ inpaint 进 MODAL 后 30 分钟内 必须调 /modal,否则后台自动 CANCEL + 退款。
video 计费控制
单段:batch_size: 1 → 扣 1 × midjourney@video
批量 4 段:batch_size: 4 → 扣 4 × midjourney@video
高清单段:video_type: "vid_1.1_i2v_720" + batch_size: 1 → 扣 1 × midjourney@video-720p
建议 :出片只要 1 段就用 batch_size=1,批量比稿才用 4,不要默认开 4(成本翻 N 倍)。
并发与吞吐
import asyncio
sem = asyncio.Semaphore(10) # 客户端最多 10 个并发提交
async def submit_one(prompt):
async with sem:
return await submit({"prompt": prompt})
平台对每分钟提交数有上限,超出返回 429,需退避重试。
实际生成并发由系统容量决定,超出会排队;任务长时间停在 SUBMITTED 通常是排队中。
轮询务必带 sleep,不要无 sleep 死循环。
监控建议
指标
参考阈值
含义
任务 SUCCESS 率(近 1h)
> 95%
偏低说明服务 / 网络异常
平均完成耗时
\< 90s
偏高说明排队
MODAL 停留任务数
接近 0
偏多说明客户端没调 /modal
code=24 比例
\< 5%
偏高说明 prompt 频繁触发敏感词
排错清单
现象
排查方向
任务长时间 SUBMITTED
系统排队中,稍后再查
任务长时间 NOT_START
平台稍后会自动超时退款,无需手动处理
任务 MODAL 超 30 分钟
客户端没调 /modal,已被自动 CANCEL + 退款
prompt 字段为空
describe 任务的文字结果在 description 字段
image_urls 少一张
内容审核拦了部分图,看 fail_reason
计费超预期
看 quota 字段;video 记得 × batch_size
完整工作流示例
计费说明 :按路径模型名计费(如 midjourney-imagine);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询推荐 GET /v1/midjourney/tasks/{task_id}(兼容 GET /v1/midjourney/{task_id})。
imagine → upscale → inpaint → video 等端到端 curl 走查,附 bash / Python / TS 客户端封装
把多接口串起来的端到端示例。所有命令把 $KEY 换成你的 API token,$HOST 换成实际平台域名。
export KEY="sk-your-api-key"
export HOST="https://api.zhaotutu.ai"
流程 A:基础文生图(imagine → upscale)
# 1. imagine 出 4 张图
curl -sS -X POST "$HOST/v1/midjourney/generations/imagine" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{
"prompt": "a futuristic city at sunset, photorealistic, cinematic lighting",
"version": "8.1", "size": "16:9", "speed": "fast", "stylize": 250
}'
# → {"code":200,"data":[{"task_id":"task_01KQVZAPBW...","status":"submitted"}]}
# 2. 轮询查询直到 SUCCESS(约 30–60s)
curl -sS "$HOST/v1/midjourney/task_01KQVZAPBW..." -H "Authorization: Bearer $KEY"
# → SUCCESS,含 grid_image_url + 4 张 image_urls + buttons(U1-U4 / V1-V4 / 🔄)
# 3. upscale 选第 2 张(本地合成,毫秒级 SUCCESS)
curl -sS -X POST "$HOST/v1/midjourney/generations/upscale" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{"task_id": "task_01KQVZAPBW...", "index": 2}'
# → 查询拿单图 image_urls[0]
流程 B:垫图 → 强变体 → 放大
# 1. 垫图 imagine
curl -sS -X POST "$HOST/v1/midjourney/generations/imagine" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{
"prompt": "turn this product into a luxury studio photo",
"image_urls": ["https://your-cdn.example.com/product.png"],
"iw": 1.5, "size": "1:1"
}'
# 2. 对结果做强变体
curl -sS -X POST "$HOST/v1/midjourney/generations/high-variation" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{"task_id": "task_01XXX...", "index": 1, "speed": "fast"}'
# 3. 对变体的某张 upscale
curl -sS -X POST "$HOST/v1/midjourney/generations/upscale" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{"task_id": "task_02_variant...", "index": 3}'
流程 C:局部重绘(inpaint + modal 两步)
前提:先 imagine + upscale 拿到单图任务(见流程 A)。
# 1. 提交 inpaint → 进 MODAL
curl -sS -X POST "$HOST/v1/midjourney/generations/inpaint" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{"task_id": "task_02_upscaled..."}'
# → {"data":[{"task_id":"task_03_inpaint...","status":"modal"}]}
# 注意 status=modal,任务等你补 mask;30 分钟超时自动 CANCEL + 退款
# 2. 前端画 mask(透明=重绘区,白色=保留),上传到自己的 OSS 拿 mask_url(须公网可达)
# 3. 提交 modal 完成
curl -sS -X POST "$HOST/v1/midjourney/generations/modal" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{
"task_id": "task_03_inpaint...",
"prompt": "replace the selected area with a red leather sofa",
"mask_url": "https://your-oss.example.com/mask-abc.png"
}'
# → 同 task_id,status 转 submitted;4. 轮询 60–90s 后 SUCCESS,含 4 张局部重绘候选
流程 D:扩图(Zoom Out)
# 直接出图,无需 mask(Outpaint / CustomZoom 都不进 MODAL)
curl -sS -X POST "$HOST/v1/midjourney/generations/zoom" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{"task_id": "task_02_upscaled...", "zoom_ratio": 1.5, "speed": "fast"}'
流程 E:图生视频(i2v)
# 720p 高清 + batch=4(4 倍计费)
curl -sS -X POST "$HOST/v1/midjourney/generations/video" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{
"prompt": "city traffic at night, neon reflections, slow camera dolly",
"image_urls": ["https://your-cdn.example.com/city.jpg"],
"video_type": "vid_1.1_i2v_720", "batch_size": 4
}'
# 实扣 = midjourney@video-720p × 4
# 起止帧 transition(end_url 自动升级为 start_end)
curl -sS -X POST "$HOST/v1/midjourney/generations/video" \
-H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
-d '{
"prompt": "transition smoothly from sunrise to sunset",
"image_urls": ["https://your-cdn.example.com/sunrise.jpg"],
"end_url": "https://your-cdn.example.com/sunset.jpg",
"video_type": "vid_1.1_i2v_720"
}'
通用工具:Python 客户端封装
import time
import httpx
API_KEY = "sk-..."
HOST = "https://api.zhaotutu.ai"
class MjClient:
def __init__(self):
self.client = httpx.Client(
base_url=HOST,
headers={"Authorization": f"Bearer {API_KEY}"},
timeout=30,
)
def imagine(self, prompt, **params):
r = self.client.post("/v1/midjourney/generations/imagine",
json={"prompt": prompt, **params})
return r.json()["data"][0]["task_id"]
def upscale(self, task_id, index):
r = self.client.post("/v1/midjourney/generations/upscale",
json={"task_id": task_id, "index": index})
return r.json()["data"][0]["task_id"]
def query(self, task_id):
return self.client.get(f"/v1/midjourney/{task_id}").json()
def wait(self, task_id, timeout=180):
deadline = time.time() + timeout
while time.time() < deadline:
t = self.query(task_id)
if t["status"] in ("SUCCESS", "FAILURE"):
return t
if t["status"] == "MODAL":
raise RuntimeError(f"task {task_id} 需要调 /modal")
time.sleep(3)
raise TimeoutError(task_id)
mj = MjClient()
imagine_id = mj.imagine("a cat", version="8.1", speed="fast", size="16:9")
mj.wait(imagine_id)
upscale_id = mj.upscale(imagine_id, 2)
print(mj.wait(upscale_id)["image_urls"][0])
通用工具:TypeScript 封装
const API_KEY = "sk-...";
const HOST = "https://api.zhaotutu.ai";
async function mj(path: string, body: any) {
const r = await fetch(`${HOST}${path}`, {
method: "POST",
headers: { "Authorization": `Bearer ${API_KEY}`, "Content-Type": "application/json" },
body: JSON.stringify(body),
});
return r.json();
}
async function query(id: string) {
const r = await fetch(`${HOST}/v1/midjourney/${id}`, {
headers: { "Authorization": `Bearer ${API_KEY}` },
});
return r.json();
}
async function waitTask(id: string, timeoutMs = 180_000) {
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
const t = await query(id);
if (t.status === "SUCCESS" || t.status === "FAILURE") return t;
if (t.status === "MODAL") throw new Error(`需要调 /modal: ${id}`);
await new Promise((r) => setTimeout(r, 3000));
}
throw new Error(`超时: ${id}`);
}
const r = await mj("/v1/midjourney/generations/imagine",
{ prompt: "a cat", version: "8.1", speed: "fast" });
const result = await waitTask(r.data[0].task_id);
console.log(result.image_urls);
状态机
submit → NOT_START(0%) → SUBMITTED(5-30%) → IN_PROGRESS(~99%) → SUCCESS(100%)
↘ FAILURE(100%) → 自动退款
inpaint / CustomZoom → MODAL(15%) ──POST /modal {mask_url, prompt}──▶ SUBMITTED → ...
└ 30min 超时 → CANCEL + 退款
Suno 通用约定与任务查询
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
Suno 音乐接口的公共说明:认证、异步任务生命周期、model / version、源音轨引用
任务查询:GET /v1/music/tasks/:task_id,轮询直到 completed / failed
本页是所有 Suno 音乐接口的公共约定,配合每个端点单独文档使用。所有生成 / 编辑接口均为异步任务 :提交拿 task_id,再轮询本页的查询接口取结果。
认证
所有请求都需要在请求头中携带:
Authorization: Bearer <你的API Key>
Content-Type: application/json
登录 控制台 →「API 令牌」获取 API Key。
任务生命周期(所有接口均为异步)
POST /v1/music/generations/<操作> → 立即返回 task_id:
{ "code": 200, "data": [ { "status": "submitted", "task_id": "task_xxx" } ] }
GET /v1/music/tasks/:task_id 直到 status 为 completed 或 failed。生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100。建议轮询间隔 3–5s;音乐生成通常 30–120s。
完成后从 data.result.music[] 取 audio_url / image_url / video_url 等。
任务状态流转:submitted → pending → completed / failed。失败时 data.error.message 给出原因,且预扣额度自动退回。
版本 version
v3.5 / v4 / v4.5 / v4.5+ / v4.5-all / v5 / v5.5,影响音质与计费;不传使用默认。各端点的可用版本与默认值不同——部分端点只支持子集,部分端点无版本维度;以各端点自身文档为准。
引用源音轨:task_id + audio_index
基于已有歌曲的操作(续写 / 翻唱 / 分轨 / 加人声 / 裁剪…)不需要 记任何额外 id,只传:
task_id:产出源音轨那次任务的 task_id
audio_index:该任务结果 music[] 里第几首(1-based,默认 1;一次生成通常 2 首:1 和 2)
无法解析源时(任务未完成 / 序号越界 / task_id 不存在),提交期直接返回 400。
查询任务:GET /v1/music/tasks/:task_id
提交接口返回的 task_id。
轮询该接口直到 status 为 completed 或 failed。完成后从 data.result.music[] 取产物。
Response
任务唯一标识符
任务状态:submitted / pending / completed / failed
进度:排队 10 → 就绪 50 → 完成 100
结果数据
status 为 completed 时存在
产物列表(一次生成通常 2 首)
音轨 id,供后续操作用 audio_index 定位
标题
时长(秒)
歌词
风格标签
音频文件 URL
封面图 URL
大图封面 URL
MV 视频 URL(若已生成)
status 为 failed 时存在
失败原因(预扣额度自动退回)
Response
completed failed
completed 复制
{
"task_id": "task_01ABC...",
"status": "completed",
"progress": 100,
"data": {
"result": {
"music": [
{
"audio_id": "<音轨id,供后续操作 audio_index 定位>",
"title": "Summer Breeze",
"duration": 128.5,
"lyrics": "……",
"tags": "electronic, upbeat",
"audio_url": "https://.../xxx.mp3",
"image_url": "https://.../cover.png",
"image_large_url": "https://.../cover_large.png",
"video_url": "https://.../mv.mp4"
}
]
}
}
}failed 复制
{
"task_id": "task_01ABC...",
"status": "failed",
"progress": 100,
"data": {
"error": {
"message": "generation failed"
}
}
}
生成音乐
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
从提示词生成歌曲:custom=false 为灵感模式(prompt 作灵感提示词),=true 为自定义模式(prompt 作歌词)。
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
custom 决定字段是否生效:写了但模式不对的字段会被静默忽略 (不报错)。custom=true(自定义)时 prompt(歌词)、title、style、negative_tags、auto_lyrics、persona_id、style_weight、weirdness_constraint、audio_weight 生效;custom=false(灵感)时 prompt 作灵感描述,title/style 及上述自定义字段被忽略。vocal_gender 两种模式都生效。
本端点走独立路由,字段名与其他端点略有不同:style(而非 tags)。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
false=灵感模式;true=自定义模式(prompt 作歌词)。默认 false。
true=纯音乐、无人声。默认 false。
生成版本:v3.5 / v4 / v4.5 / v4.5+ / v4.5-all / v5 / v5.5,影响音质与计费。两种模式下均必填,不传直接返回 400 。
灵感提示词 / 歌词。custom=false 时必填 (作灵感描述);custom=true 时:instrumental=false 则必填 (作歌词),instrumental=true 可不填。缺失时提交期直接返回 400(不扣费)。
标题(自定义模式)。custom=false(灵感模式)时忽略 。
风格标签(自定义模式)。custom=false(灵感模式)时忽略 。
负向风格标签(不希望出现的风格)。仅 custom=true 时生效 。
true=对输入歌词进行二次创作。仅 custom=true 时生效 。
Persona 风格 id。仅 custom=true 时生效 。
人声性别:Male / Female(也接受 m / f / male / female,后端自动归一)。两种模式均生效 。
风格权重,0.00–1.00。仅 custom=true 时生效 。
创意度,0.00–1.00。仅 custom=true 时生效 。
音频权重,0.00–1.00。仅 custom=true 时生效 。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后在 data.result.music[] 取 audio_url(另有 image_url / video_url / title / duration 等)。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL cURL(自定义模式) Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"custom": false,
"version": "v5",
"prompt": "深夜城市 lo-fi 钢琴配雨声"
}'cURL(自定义模式) 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"version": "v4.5+",
"custom": true,
"instrumental": false,
"prompt": "[Verse]\n雨夜霓虹灯下的街道",
"title": "深夜驾驶",
"style": "synthwave, female vocal, cinematic",
"negative_tags": "metal, screaming",
"auto_lyrics": false,
"vocal_gender": "Female",
"style_weight": 0.6,
"weirdness_constraint": 0.3,
"audio_weight": 0.5
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations"
payload = {
"model": "suno",
"custom": False,
"version": "v5",
"prompt": "深夜城市 lo-fi 钢琴配雨声"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations";
const payload = {
model: "suno",
custom: false,
version: "v5",
prompt: "深夜城市 lo-fi 钢琴配雨声"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations"
payload := map[string]interface{}{
"model": "suno",
"custom": false,
"version": "v5",
"prompt": "深夜城市 lo-fi 钢琴配雨声",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations";
String payload = """
{
"model": "suno",
"custom": false,
"version": "v5",
"prompt": "深夜城市 lo-fi 钢琴配雨声"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations";
$payload = [
"model" => "suno",
"custom" => false,
"version" => "v5",
"prompt" => "深夜城市 lo-fi 钢琴配雨声"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations")
payload = {
model: "suno",
custom: false,
version: "v5",
prompt: "深夜城市 lo-fi 钢琴配雨声"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations")!
let payload: [String: Any] = [
"model": "suno",
"custom": false,
"version": "v5",
"prompt": "深夜城市 lo-fi 钢琴配雨声"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations";
var payload = @"{
""model"": ""suno"",
""custom"": false,
""version"": ""v5"",
""prompt"": ""深夜城市 lo-fi 钢琴配雨声""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations";
const char *payload = "{"
"\"model\":\"suno\","
"\"custom\":false,"
"\"version\":\"v5\","
"\"prompt\":\"深夜城市 lo-fi 钢琴配雨声\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations"];
NSDictionary *payload = @{
@"model": @"suno",
@"custom": @NO,
@"version": @"v5",
@"prompt": @"深夜城市 lo-fi 钢琴配雨声"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations"
let payload = {|{
"model": "suno",
"custom": false,
"version": "v5",
"prompt": "深夜城市 lo-fi 钢琴配雨声"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations');
final payload = {
'model': 'suno',
'custom': false,
'version': 'v5',
'prompt': '深夜城市 lo-fi 钢琴配雨声'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations"
payload <- list(
model = "suno",
custom = FALSE,
version = "v5",
prompt = "深夜城市 lo-fi 钢琴配雨声"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
生成歌词
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
根据主题生成歌词文本。
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
本端点无版本维度 :不要传 version,传了会被丢弃,也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
歌词 / 内容。
歌词模型:classic / remi(透传;不传则用默认)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后结果里含生成的歌词文本。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/lyrics \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"prompt": "一首关于重逢的抒情歌"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/lyrics"
payload = {
"model": "suno",
"prompt": "一首关于重逢的抒情歌"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/lyrics";
const payload = {
model: "suno",
prompt: "一首关于重逢的抒情歌"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/lyrics"
payload := map[string]interface{}{
"model": "suno",
"prompt": "一首关于重逢的抒情歌",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/lyrics";
String payload = """
{
"model": "suno",
"prompt": "一首关于重逢的抒情歌"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/lyrics";
$payload = [
"model" => "suno",
"prompt" => "一首关于重逢的抒情歌"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/lyrics")
payload = {
model: "suno",
prompt: "一首关于重逢的抒情歌"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/lyrics")!
let payload: [String: Any] = [
"model": "suno",
"prompt": "一首关于重逢的抒情歌"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/lyrics";
var payload = @"{
""model"": ""suno"",
""prompt"": ""一首关于重逢的抒情歌""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/lyrics";
const char *payload = "{"
"\"model\":\"suno\","
"\"prompt\":\"一首关于重逢的抒情歌\\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/lyrics"];
NSDictionary *payload = @{
@"model": @"suno",
@"prompt": @"一首关于重逢的抒情歌"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/lyrics"
let payload = {|{
"model": "suno",
"prompt": "一首关于重逢的抒情歌"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/lyrics');
final payload = {
'model': 'suno',
'prompt': '一首关于重逢的抒情歌'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/lyrics"
payload <- list(
model = "suno",
prompt = "一首关于重逢的抒情歌"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
续写延长
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
在已有歌曲的某个时间点之后续写延长。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
extend 的 custom 不强制、也不做推断——传就透传,不传也能正常续写。custom=true 时按 prompt(歌词)续写;custom=false 或不传时可用 gpt_description(灵感描述)引导续写方向。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id;缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
从第几秒开始续写。
生成版本:v3.5 / v4 / v4.5 / v4.5+ / v4.5-all / v5 / v5.5,影响音质与计费;不传默认 v5.5,非法值提交期直接返回 400。
不传即可(extend 不强制)。true=按 prompt 歌词续写;false=灵感续写。
续写歌词,custom=true 时生效。
灵感提示词,custom=false/不传时生效(引导续写方向)。
标题。仅 custom=true 时生效 。
风格标签。仅 custom=true 时生效 。
排除的风格标签。仅 custom=true 时生效 。
人声性别:Male / Female。两种模式均生效 。
风格权重,0.00–1.00(超出范围提交期直接返回 400)。仅 custom=true 时生效 。
创意度权重,0.00–1.00(别名 weirdness)。仅 custom=true 时生效 。
音频权重,0.00–1.00。仅 custom=true 时生效 。
true=对输入歌词进行二次创作。仅 custom=true 时生效 。
Persona 风格 id。仅 custom=true 时生效 。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后在 data.result.music[] 取延长后的 audio_url。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/extend \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"continue_at": 120,
"version": "v5",
"prompt": "续写歌词…"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/extend"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"continue_at": 120,
"version": "v5",
"prompt": "续写歌词…"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/extend";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
continue_at: 120,
version: "v5",
prompt: "续写歌词…"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/extend"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"continue_at": 120,
"version": "v5",
"prompt": "续写歌词…",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/extend";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"continue_at": 120,
"version": "v5",
"prompt": "续写歌词…"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/extend";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"continue_at" => 120,
"version" => "v5",
"prompt" => "续写歌词…"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/extend")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
continue_at: 120,
version: "v5",
prompt: "续写歌词…"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/extend")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"continue_at": 120,
"version": "v5",
"prompt": "续写歌词…"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/extend";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""continue_at"": 120,
""version"": ""v5"",
""prompt"": ""续写歌词…""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/extend";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"continue_at\":120,"
"\"version\":\"v5\","
"\"prompt\":\"续写歌词…\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/extend"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"continue_at": @120,
@"version": @"v5",
@"prompt": @"续写歌词…"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/extend"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"continue_at": 120,
"version": "v5",
"prompt": "续写歌词…"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/extend');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'continue_at': 120,
'version': 'v5',
'prompt': '续写歌词…'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/extend"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
continue_at = 120,
version = "v5",
prompt = "续写歌词…"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
上传音频
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
把一段公网音频导入,得到可供后续(翻唱 / 续写等)引用的音轨;完成后本任务 task_id 即可作源(audio_index=1)。
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
本端点无版本维度 :不要传 version,传了会被丢弃,也不影响计费。
已知限制 :不要上传**纯器乐(无人声)**音频,可能解析失败。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
公网可访问的音频直链;缺失时提交期直接返回 400(不扣费)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后用本任务 task_id + audio_index=1 作为其它操作的源。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/uploadTask \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"audioFilePath": "https://example.com/my.mp3"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/uploadTask"
payload = {
"model": "suno",
"audioFilePath": "https://example.com/my.mp3"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/uploadTask";
const payload = {
model: "suno",
audioFilePath: "https://example.com/my.mp3"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/uploadTask"
payload := map[string]interface{}{
"model": "suno",
"audioFilePath": "https://example.com/my.mp3",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/uploadTask";
String payload = """
{
"model": "suno",
"audioFilePath": "https://example.com/my.mp3"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/uploadTask";
$payload = [
"model" => "suno",
"audioFilePath" => "https://example.com/my.mp3"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/uploadTask")
payload = {
model: "suno",
audioFilePath: "https://example.com/my.mp3"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/uploadTask")!
let payload: [String: Any] = [
"model": "suno",
"audioFilePath": "https://example.com/my.mp3"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/uploadTask";
var payload = @"{
""model"": ""suno"",
""audioFilePath"": ""https://example.com/my.mp3""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/uploadTask";
const char *payload = "{"
"\"model\":\"suno\","
"\"audioFilePath\":\"https://example.com/my.mp3\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/uploadTask"];
NSDictionary *payload = @{
@"model": @"suno",
@"audioFilePath": @"https://example.com/my.mp3"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/uploadTask"
let payload = {|{
"model": "suno",
"audioFilePath": "https://example.com/my.mp3"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/uploadTask');
final payload = {
'model': 'suno',
'audioFilePath': 'https://example.com/my.mp3'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/uploadTask"
payload <- list(
model = "suno",
audioFilePath = "https://example.com/my.mp3"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
风格翻唱
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
以另一种风格翻唱已有歌曲。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
custom 决定字段是否生效:写了但模式不对的字段会被静默忽略 (不报错)。custom=true 时 prompt(歌词)、title、tags、negative_tags、style_weight、weirdness_constraint、audio_weight、persona_id 生效,gpt_description 被忽略;custom=false 时只认 gpt_description(此时必填 ,缺了提交期直接 400)。vocal_gender 两种模式都生效。不传 custom 时后端按此顺序推断:有 prompt → true;无 prompt 但有 gpt_description → false;否则有 tags/title → true。
用法
用法 A —— 指定风格翻唱(最常用,推荐)
给源歌曲 + 目标风格 tags,不用管 custom(系统看到 tags 会自动按 custom=true 处理):
{
"model": "suno",
"task_id": "task_xxx", // 源歌曲:一个已完成的音乐任务
"audio_index": 1, // 源任务里第几首(1-based,默认 1)
"version": "v5",
"tags": "jazz, slow" // 目标风格 → 自动 custom=true
}
想更精确可以再加 prompt(歌词)/ title。
用法 B —— 灵感模式(custom=false)
不指定具体风格,让模型自己发挥,但必须给 gpt_description 描述你想要的效果:
{
"model": "suno",
"task_id": "task_xxx",
"audio_index": 1,
"version": "v5",
"custom": false,
"gpt_description": "把这首歌翻唱成慢速爵士风格" // custom=false 时必填
}
两种用法二选一,别只传 custom=false 却不给 gpt_description(会提交期直接 400)。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id;缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based:1=第 1 首;默认 1;一次生成通常 2 首:索引 1 与 2)。
生成版本:v3.5 / v4 / v4.5 / v4.5+ / v4.5-all / v5 / v5.5,影响音质与计费;不传默认 v5.5,非法值提交期直接返回 400。
true=自定义模式(用 prompt 作歌词);false=灵感模式(用 gpt_description);不传时按内容推断(见上方 Warning)。
歌词,custom=true 时生效(灵感模式下会被忽略)。
灵感提示词,custom=false 时必填 (缺了提交期直接 400、不扣费)。
标题。仅 custom=true 时生效 。
目标风格标签。仅 custom=true 时生效 。
排除的风格标签。仅 custom=true 时生效 。
风格权重,0.00–1.00(超出范围提交期直接返回 400)。仅 custom=true 时生效 。
创意度权重,0.00–1.00(别名 weirdness)。仅 custom=true 时生效 。
音频权重,0.00–1.00。仅 custom=true 时生效 。
人声性别:Male / Female。两种模式均生效 。
Persona 风格 id。仅 custom=true 时生效 。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后在 data.result.music[] 取 audio_url。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/coverSong \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "jazz, slow"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/coverSong"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "jazz, slow"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/coverSong";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5",
tags: "jazz, slow"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/coverSong"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "jazz, slow",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/coverSong";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "jazz, slow"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/coverSong";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"version" => "v5",
"tags" => "jazz, slow"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/coverSong")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5",
tags: "jazz, slow"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/coverSong")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "jazz, slow"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/coverSong";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""version"": ""v5"",
""tags"": ""jazz, slow""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/coverSong";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"version\":\"v5\","
"\"tags\":\"jazz, slow\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/coverSong"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"version": @"v5",
@"tags": @"jazz, slow"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/coverSong"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "jazz, slow"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/coverSong');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'version': 'v5',
'tags': 'jazz, slow'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/coverSong"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
version = "v5",
tags = "jazz, slow"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
完整歌曲合成 / 拼接
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
把片段合成为完整歌曲。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
前提 :concat 只能拼接 extend(续写)产生的分段结果 。若源不是 extend 产物(如普通一次性生成的整首歌),提交期直接返回 400。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
源任务的 task_id——必须是 extend(续写)产生的分段 (见上方 Warning)。缺失、非 extend 产物或无法解析源时,提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取完整歌曲 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/concat \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/concat"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/concat";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/concat"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/concat";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/concat";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/concat")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/concat")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/concat";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/concat";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/concat"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/concat"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/concat');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/concat"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
分轨提取
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
从歌曲分离出指定轨(如人声)。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version,传了会被丢弃,也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id;缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
要提取的轨,不传默认 lead_vocal(主人声)。支持 100+ 枚举,常用:lead_vocal / backing_vocals / drum_kit / bass / piano / electric_guitar / … 。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后结果里含分离出的轨 URL。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/stems \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"stem_type": "lead_vocal"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/stems"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"stem_type": "lead_vocal"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/stems";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
stem_type: "lead_vocal"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/stems"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"stem_type": "lead_vocal",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/stems";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"stem_type": "lead_vocal"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/stems";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"stem_type" => "lead_vocal"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/stems")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
stem_type: "lead_vocal"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/stems")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"stem_type": "lead_vocal"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/stems";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""stem_type"": ""lead_vocal""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/stems";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"stem_type\":\"lead_vocal\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/stems"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"stem_type": @"lead_vocal"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/stems"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"stem_type": "lead_vocal"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/stems');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'stem_type': 'lead_vocal'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/stems"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
stem_type = "lead_vocal"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
全量分轨
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
多轨全分离。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version,传了会被丢弃,也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id;缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后结果里含各分轨 URL。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/stemsAll \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/stemsAll"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/stemsAll";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/stemsAll"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/stemsAll";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/stemsAll";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/stemsAll")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/stemsAll")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/stemsAll";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/stemsAll";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/stemsAll"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/stemsAll"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/stemsAll');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/stemsAll"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
添加人声
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
给现有(伴奏 / 音轨)叠加人声。
源音轨限用 uploadTask 上传的自有音轨:传该上传任务的 task_id + audio_index;用生成的音轨作源会失败
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :源音轨必须是你用 uploadTask 上传的自有音频,传该上传任务的 task_id + audio_index(结果 music[] 里第几首,1-based,默认 1)。用生成的音轨作源会失败 ,只能引用自己上传的音轨。
custom 决定字段是否生效:写了但模式不对的字段会被静默忽略 (不报错)。custom=true 时 prompt(歌词)、title、tags、negative_tags、style_weight、weirdness_constraint、audio_weight 生效,gpt_description 被忽略;custom=false 时只认 gpt_description(此时必填 ,缺了提交期直接 400)。vocal_gender 两种模式都生效。不传 custom 时后端按此顺序推断:有 prompt → true;无 prompt 但有 gpt_description → false;否则有 tags/title → true。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
源音轨所在 uploadTask 上传任务的 task_id(须为你自己上传的音轨;用生成任务的音轨作源会失败)。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
生成版本:仅 v5 / v5.5 ;不传默认 v5.5。传其它值提交期直接返回 400。
true=自定义模式(用 prompt 作歌词);false=灵感模式(用 gpt_description);不传时按内容推断(见上方 Warning)。
歌词,custom=true 时生效(灵感模式下会被忽略)。
灵感提示词,custom=false 时必填 (缺了提交期直接 400、不扣费)。
标题。仅 custom=true 时生效 。
风格标签。仅 custom=true 时生效 。
排除的风格标签。仅 custom=true 时生效 。
风格权重,0.00–1.00(超出范围提交期直接返回 400)。仅 custom=true 时生效 。
创意度权重,0.00–1.00(别名 weirdness)。仅 custom=true 时生效 。
音频权重,0.00–1.00。仅 custom=true 时生效 。
人声性别:Male / Female。两种模式均生效 。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后在 data.result.music[] 取 audio_url。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/addVocals \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"custom": true,
"prompt": "…歌词…"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/addVocals"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"custom": True,
"prompt": "…歌词…"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/addVocals";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5",
custom: true,
prompt: "…歌词…"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/addVocals"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"custom": true,
"prompt": "…歌词…",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/addVocals";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"custom": true,
"prompt": "…歌词…"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/addVocals";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"version" => "v5",
"custom" => true,
"prompt" => "…歌词…"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/addVocals")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5",
custom: true,
prompt: "…歌词…"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/addVocals")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"custom": true,
"prompt": "…歌词…"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/addVocals";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""version"": ""v5"",
""custom"": true,
""prompt"": ""…歌词…""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/addVocals";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"version\":\"v5\","
"\"custom\":true,"
"\"prompt\":\"…歌词…\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/addVocals"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"version": @"v5",
@"custom": @YES,
@"prompt": @"…歌词…"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/addVocals"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"custom": true,
"prompt": "…歌词…"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/addVocals');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'version': 'v5',
'custom': true,
'prompt': '…歌词…'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/addVocals"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
version = "v5",
custom = TRUE,
prompt = "…歌词…"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
添加伴奏
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
给现有(人声 / 音轨)叠加伴奏。
源音轨限用 uploadTask 上传的自有音轨:传该上传任务的 task_id + audio_index;用生成的音轨作源会失败
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :源音轨必须是你用 uploadTask 上传的自有音频,传该上传任务的 task_id + audio_index(结果 music[] 里第几首,1-based,默认 1)。用生成的音轨作源会失败 ,只能引用自己上传的音轨。
custom 决定哪些字段生效:写在错误模式下的字段会被静默忽略 (不报错)。custom=true 时 prompt(歌词)、title、tags、negative_tags、style_weight、weirdness_constraint、audio_weight 生效,gpt_description 被忽略;custom=false 时只读 gpt_description(此时必填 ,缺了提交期直接返回 400)。vocal_gender 两种模式都生效。不传 custom 时后端按此顺序推断:有 prompt → true;无 prompt 但有 gpt_description → false;否则有 tags/title → true。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
源音轨所在 uploadTask 上传任务的 task_id(须为你自己上传的音轨;用生成任务的音轨作源会失败)。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
生成版本:仅 v5 / v5.5 ;不传默认 v5.5。传其它值提交期直接返回 400。
true=自定义模式(用 prompt 作歌词);false=灵感模式(用 gpt_description);不传时按内容推断(见上方 Warning)。
歌词,custom=true 时生效(灵感模式下会被忽略)。
灵感提示词,custom=false 时必填 (缺了提交期直接 400、不扣费)。
标题。仅 custom=true 时生效 。
风格标签。仅 custom=true 时生效 。
要排除的风格标签。仅 custom=true 时生效 。
风格权重,0.00–1.00(越界提交期直接返回 400)。仅 custom=true 时生效 。
创意权重,0.00–1.00(别名 weirdness)。仅 custom=true 时生效 。
音频权重,0.00–1.00。仅 custom=true 时生效 。
人声性别:Male / Female。两种模式都生效 。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/addInstrumental \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "lo-fi"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/addInstrumental"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "lo-fi"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/addInstrumental";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5",
tags: "lo-fi"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/addInstrumental"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "lo-fi",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/addInstrumental";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "lo-fi"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/addInstrumental";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"version" => "v5",
"tags" => "lo-fi"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/addInstrumental")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5",
tags: "lo-fi"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/addInstrumental")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "lo-fi"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/addInstrumental";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""version"": ""v5"",
""tags"": ""lo-fi""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/addInstrumental";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"version\":\"v5\","
"\"tags\":\"lo-fi\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/addInstrumental"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"version": @"v5",
@"tags": @"lo-fi"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/addInstrumental"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
"tags": "lo-fi"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/addInstrumental');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'version': 'v5',
'tags': 'lo-fi'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/addInstrumental"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
version = "v5",
tags = "lo-fi"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
添加音轨 (add stem)
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
在现有音轨上叠加一条 stem。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
custom 决定哪些字段生效:写在错误模式下的字段会被静默忽略 (不报错)。custom=true 时 prompt(歌词)、title、tags、negative_tags、style_weight、weirdness_constraint、audio_weight 生效,gpt_description 被忽略;custom=false 时只读 gpt_description(此时必填 ,缺了提交期直接返回 400)。不传 custom 时后端按此顺序推断:有 prompt → true;无 prompt 但有 gpt_description → false;否则有 tags/title → true。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
生成版本:仅 v5.5 ;不传默认 v5.5。传其它值提交期直接返回 400(v3.5 / v4 报错;v4.5 / v5 会卡在 10% 直到任务超时)。
true=自定义模式(用 prompt 作歌词);false=灵感模式(用 gpt_description);不传时按内容推断(见上方 Warning)。
歌词,custom=true 时生效(灵感模式下会被忽略)。
灵感提示词,custom=false 时必填 (缺了提交期直接 400、不扣费)。
标题。仅 custom=true 时生效 。
风格标签。仅 custom=true 时生效 。
要排除的风格标签。仅 custom=true 时生效 。
风格权重,0.00–1.00(越界提交期直接返回 400)。仅 custom=true 时生效 。
创意权重,0.00–1.00(别名 weirdness)。仅 custom=true 时生效 。
音频权重,0.00–1.00。仅 custom=true 时生效 。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/addStem \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5.5"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/addStem"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5.5"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/addStem";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5.5"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/addStem"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5.5",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/addStem";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5.5"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/addStem";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"version" => "v5.5"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/addStem")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5.5"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/addStem")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5.5"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/addStem";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""version"": ""v5.5""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/addStem";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"version\":\"v5.5\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/addStem"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"version": @"v5.5"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/addStem"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5.5"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/addStem');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'version': 'v5.5'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/addStem"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
version = "v5.5"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
段落替换
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
替换歌曲的某一段(infill)。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
替换段歌词。
替换起点(秒)。缺失直接返回 400。
替换终点(秒)。缺失直接返回 400。
生成版本:v4 / v4.5+ / v5 / v5.5;不传默认 v5.5。传其它值(含 v3.5 / v4.5 / v4.5-all)提交期直接返回 400。
上下文歌词。
标题。
风格标签。
要排除的风格标签。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取替换后的 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/replaceMusic \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45,
"infill_lyrics": "新的一段歌词"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/replaceMusic"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45,
"infill_lyrics": "新的一段歌词"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/replaceMusic";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
start_s: 30,
end_s: 45,
infill_lyrics: "新的一段歌词"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/replaceMusic"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45,
"infill_lyrics": "新的一段歌词",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/replaceMusic";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45,
"infill_lyrics": "新的一段歌词"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/replaceMusic";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"start_s" => 30,
"end_s" => 45,
"infill_lyrics" => "新的一段歌词"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/replaceMusic")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
start_s: 30,
end_s: 45,
infill_lyrics: "新的一段歌词"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/replaceMusic")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45,
"infill_lyrics": "新的一段歌词"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/replaceMusic";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""start_s"": 30,
""end_s"": 45,
""infill_lyrics"": ""新的一段歌词""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/replaceMusic";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"start_s\":30,"
"\"end_s\":45,"
"\"infill_lyrics\":\"新的一段歌词\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/replaceMusic"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"start_s": @30,
@"end_s": @45,
@"infill_lyrics": @"新的一段歌词"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/replaceMusic"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45,
"infill_lyrics": "新的一段歌词"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/replaceMusic');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'start_s': 30,
'end_s': 45,
'infill_lyrics': '新的一段歌词'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/replaceMusic"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
start_s = 30,
end_s = 45,
infill_lyrics = "新的一段歌词"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
删除片段
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
删除歌曲的某个时间区间。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
删除起点(秒)。缺失直接返回 400。
删除终点(秒)。缺失直接返回 400。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取处理后的 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/removeSection \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/removeSection"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/removeSection";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
start_s: 30,
end_s: 45
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/removeSection"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/removeSection";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/removeSection";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"start_s" => 30,
"end_s" => 45
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/removeSection")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
start_s: 30,
end_s: 45
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/removeSection")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/removeSection";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""start_s"": 30,
""end_s"": 45
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/removeSection";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"start_s\":30,"
"\"end_s\":45"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/removeSection"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"start_s": @30,
@"end_s": @45
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/removeSection"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 30,
"end_s": 45
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/removeSection');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'start_s': 30,
'end_s': 45
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/removeSection"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
start_s = 30,
end_s = 45
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
裁剪音频
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
裁剪保留指定区间。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
裁剪起点(秒)。缺失直接返回 400。
裁剪终点(秒)。缺失直接返回 400。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取裁剪后的 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/crop \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 10,
"end_s": 40
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/crop"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 10,
"end_s": 40
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/crop";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
start_s: 10,
end_s: 40
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/crop"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 10,
"end_s": 40,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/crop";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 10,
"end_s": 40
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/crop";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"start_s" => 10,
"end_s" => 40
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/crop")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
start_s: 10,
end_s: 40
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/crop")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 10,
"end_s": 40
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/crop";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""start_s"": 10,
""end_s"": 40
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/crop";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"start_s\":10,"
"\"end_s\":40"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/crop"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"start_s": @10,
@"end_s": @40
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/crop"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 10,
"end_s": 40
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/crop');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'start_s': 10,
'end_s': 40
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/crop"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
start_s = 10,
end_s = 40
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
淡入
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
开头淡入。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
淡入时长(秒)。缺失直接返回 400。
标题(默认 Untitled)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取处理后的 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/fadeIn \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/fadeIn"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/fadeIn";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
duration_s: 3
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/fadeIn"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/fadeIn";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/fadeIn";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"duration_s" => 3
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/fadeIn")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
duration_s: 3
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/fadeIn")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/fadeIn";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""duration_s"": 3
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/fadeIn";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"duration_s\":3"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/fadeIn"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"duration_s": @3
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/fadeIn"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/fadeIn');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'duration_s': 3
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/fadeIn"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
duration_s = 3
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
淡出
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
结尾淡出。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
淡出时长(秒)。缺失直接返回 400。
标题(默认 Untitled)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取处理后的 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/fadeOut \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/fadeOut"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/fadeOut";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
duration_s: 3
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/fadeOut"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/fadeOut";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/fadeOut";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"duration_s" => 3
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/fadeOut")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
duration_s: 3
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/fadeOut")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/fadeOut";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""duration_s"": 3
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/fadeOut";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"duration_s\":3"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/fadeOut"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"duration_s": @3
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/fadeOut"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"duration_s": 3
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/fadeOut');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'duration_s': 3
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/fadeOut"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
duration_s = 3
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
调整速度
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
变速(不改音高)。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
倍速,范围 0.25~4,如 1.25。缺失或越界提交期直接返回 400。
变速时是否保持原音高(默认 true)。
标题(默认 Untitled)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取处理后的 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/adjustSpeed \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"speed": 1.25
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"speed": 1.25
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
speed: 1.25
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"speed": 1.25,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"speed": 1.25
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"speed" => 1.25
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/adjustSpeed")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
speed: 1.25
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"speed": 1.25
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""speed"": 1.25
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"speed\":1.25"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/adjustSpeed"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"speed": @1.25
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"speed": 1.25
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/adjustSpeed');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'speed': 1.25
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/adjustSpeed"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
speed = 1.25
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
母带优化
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
对已生成歌曲做母带优化,提升音质、清晰度与整体质感。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id;缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
生成版本:仅 v4.5+ / v5 / v5.5 ;不传默认 v5.5。传 v3.5 / v4 / v4.5 / v4.5-all 等其它值提交期直接返回 400(带支持列表)。
改编强度:subtle / normal / high。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后在 data.result.music[] 取优化后的 audio_url。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/remaster \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/remaster"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/remaster";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/remaster"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/remaster";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/remaster";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"version" => "v5"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/remaster")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
version: "v5"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/remaster")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/remaster";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""version"": ""v5""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/remaster";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"version\":\"v5\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/remaster"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"version": @"v5"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/remaster"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"version": "v5"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/remaster');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'version': 'v5'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/remaster"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
version = "v5"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
生成音乐视频 (MV)
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
为歌曲生成 MV 视频。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取 video_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/generateMp4 \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/generateMp4"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/generateMp4";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/generateMp4"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/generateMp4";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/generateMp4";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/generateMp4")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/generateMp4")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/generateMp4";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/generateMp4";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/generateMp4"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/generateMp4"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/generateMp4');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/generateMp4"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
导出 WAV
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
把歌曲导出为 WAV。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。结果里含 WAV 文件 URL。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/wav \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/wav"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/wav";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/wav"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/wav";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/wav";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/wav")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/wav")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/wav";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/wav";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/wav"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/wav"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/wav');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/wav"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
生成 MIDI
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
从歌曲生成 MIDI。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。结果里含 MIDI 产物 URL。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/midi \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/midi"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/midi";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/midi"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/midi";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/midi";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/midi")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/midi")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/midi";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/midi";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/midi"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/midi"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/midi');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/midi"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
BPM 分析
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
分析歌曲 BPM。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。结果里含 BPM 数值。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/bpm \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/bpm"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/bpm";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/bpm"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/bpm";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/bpm";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/bpm")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/bpm")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/bpm";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/bpm";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/bpm"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/bpm"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/bpm');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/bpm"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
歌词时间轴
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
生成逐句对齐的歌词时间轴。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。结果里含带时间戳的歌词。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/alignedLyrics \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/alignedLyrics")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/alignedLyrics"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/alignedLyrics');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/alignedLyrics"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
音效生成
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
根据描述生成音效。
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
生成版本:仅 v5 / v5.5,不传默认 v5.5。
音效文本描述;缺失时提交期直接返回 400(不扣费)。建议尽量使用英文提示词,效果更佳。
音效类型:one-shot(默认,单次)/ loop(可循环)。
速度,1–300;超出范围提交期直接返回 400。
调性枚举:大调 C / C# / D / D# / E / F / F# / G / G# / A / A# / B;小调在后面加 m(Cm / C#m / … / Bm)。仅支持升号(#)写法,降号(Db / Eb 等)与 B# 会返回 400(key param error)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后在 data.result.music[] 取 audio_url。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/sounds \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"prompt": "雷雨与远处的钟声"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/sounds"
payload = {
"model": "suno",
"prompt": "雷雨与远处的钟声"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/sounds";
const payload = {
model: "suno",
prompt: "雷雨与远处的钟声"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/sounds"
payload := map[string]interface{}{
"model": "suno",
"prompt": "雷雨与远处的钟声",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/sounds";
String payload = """
{
"model": "suno",
"prompt": "雷雨与远处的钟声"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/sounds";
$payload = [
"model" => "suno",
"prompt" => "雷雨与远处的钟声"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/sounds")
payload = {
model: "suno",
prompt: "雷雨与远处的钟声"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/sounds")!
let payload: [String: Any] = [
"model": "suno",
"prompt": "雷雨与远处的钟声"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/sounds";
var payload = @"{
""model"": ""suno"",
""prompt"": ""雷雨与远处的钟声""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/sounds";
const char *payload = "{"
"\"model\":\"suno\","
"\"prompt\":\"雷雨与远处的钟声\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/sounds"];
NSDictionary *payload = @{
@"model": @"suno",
@"prompt": @"雷雨与远处的钟声"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/sounds"
let payload = {|{
"model": "suno",
"prompt": "雷雨与远处的钟声"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/sounds');
final payload = {
'model': 'suno',
'prompt': '雷雨与远处的钟声'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/sounds"
payload <- list(
model = "suno",
prompt = "雷雨与远处的钟声"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
灵感生成 (inspo)
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
用 1–4 段公网音频作为灵感参考生成新歌(直接给音频 URL,不走 task_id)。
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
1–4 个可公开访问的音频 URL 数组。
生成版本:v4 / v4.5 / v4.5+ / v4.5-all / v5 / v5.5,影响音质与计费;不传默认 v5.5。
歌词 / 内容。
标题。
风格标签。
排除的风格标签。
风格权重,0.00–1.00。
创意度权重,0.00–1.00(别名 weirdness)。
音频权重,0.00–1.00。
人声性别:Male / Female。
true=对输入歌词进行二次创作。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后在 data.result.music[] 取 audio_url。失败时 data.error.message 为原因,自动退回预扣额度。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/inspo \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"audio_urls": [
"https://a/1.mp3",
"https://a/2.mp3"
],
"version": "v5",
"tags": "dreamy pop"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/inspo"
payload = {
"model": "suno",
"audio_urls": ["https://a/1.mp3", "https://a/2.mp3"],
"version": "v5",
"tags": "dreamy pop"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/inspo";
const payload = {
model: "suno",
audio_urls: ["https://a/1.mp3", "https://a/2.mp3"],
version: "v5",
tags: "dreamy pop"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/inspo"
payload := map[string]interface{}{
"model": "suno",
"audio_urls": []string{"https://a/1.mp3", "https://a/2.mp3"},
"version": "v5",
"tags": "dreamy pop",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/inspo";
String payload = """
{
"model": "suno",
"audio_urls": [
"https://a/1.mp3",
"https://a/2.mp3"
],
"version": "v5",
"tags": "dreamy pop"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/inspo";
$payload = [
"model" => "suno",
"audio_urls" => ["https://a/1.mp3", "https://a/2.mp3"],
"version" => "v5",
"tags" => "dreamy pop"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/inspo")
payload = {
model: "suno",
audio_urls: ["https://a/1.mp3", "https://a/2.mp3"],
version: "v5",
tags: "dreamy pop"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/inspo")!
let payload: [String: Any] = [
"model": "suno",
"audio_urls": ["https://a/1.mp3", "https://a/2.mp3"],
"version": "v5",
"tags": "dreamy pop"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/inspo";
var payload = @"{
""model"": ""suno"",
""audio_urls"": [
""https://a/1.mp3"",
""https://a/2.mp3""
],
""version"": ""v5"",
""tags"": ""dreamy pop""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/inspo";
const char *payload = "{"
"\"model\":\"suno\","
"\"audio_urls\":[\"https://a/1.mp3\",\"https://a/2.mp3\"],"
"\"version\":\"v5\","
"\"tags\":\"dreamy pop\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/inspo"];
NSDictionary *payload = @{
@"model": @"suno",
@"audio_urls": @[@"https://a/1.mp3", @"https://a/2.mp3"],
@"version": @"v5",
@"tags": @"dreamy pop"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/inspo"
let payload = {|{
"model": "suno",
"audio_urls": [
"https://a/1.mp3",
"https://a/2.mp3"
],
"version": "v5",
"tags": "dreamy pop"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/inspo');
final payload = {
'model': 'suno',
'audio_urls': ['https://a/1.mp3', 'https://a/2.mp3'],
'version': 'v5',
'tags': 'dreamy pop'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/inspo"
payload <- list(
model = "suno",
audio_urls = c("https://a/1.mp3", "https://a/2.mp3"),
version = "v5",
tags = "dreamy pop"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
样本转歌曲 (sample)
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
以样本为基础生成歌曲。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
custom 决定哪些字段生效:写在错误模式下的字段会被静默忽略 (不报错)。custom=true 时 prompt(歌词)、title、tags、negative_tags、auto_lyrics、style_weight、weirdness_constraint、audio_weight 生效,gpt_description 被忽略;custom=false 时只读 gpt_description(此时必填 ,缺了提交期直接返回 400)。vocal_gender 两种模式都生效。不传 custom 时后端按此顺序推断:有 prompt → true;无 prompt 但有 gpt_description → false;否则有 tags/title → true。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id(通常为上传的样本)。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based:1=第 1 首;默认 1;一次生成通常 2 首:索引 1 与 2)。
采样起点(秒)。缺失直接返回 400。
采样终点(秒)。缺失直接返回 400。
是否纯器乐(true=无人声);不传默认 false(要人声)。
生成版本:v3.5 / v4 / v4.5 / v4.5+ / v4.5-all / v5 / v5.5,影响音质与计费;不传默认 v5.5,非法值提交期直接返回 400。
true=自定义模式(用 prompt 作歌词);false=灵感模式(用 gpt_description);不传时按内容推断(见上方 Warning)。
歌词,custom=true 时生效(灵感模式下会被忽略)。
灵感提示词,custom=false 时必填 (缺了提交期直接 400、不扣费)。
标题。仅 custom=true 时生效 。
风格标签。仅 custom=true 时生效 。
要排除的风格标签。仅 custom=true 时生效 。
true=对输入歌词进行二次创作。仅 custom=true 时生效 。
风格权重,0.00–1.00(越界提交期直接返回 400)。仅 custom=true 时生效 。
创意权重,0.00–1.00(别名 weirdness)。仅 custom=true 时生效 。
音频权重,0.00–1.00。仅 custom=true 时生效 。
人声性别:Male / Female。两种模式都生效 。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/sample \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 0,
"end_s": 8,
"instrumental": false,
"version": "v5",
"tags": "upbeat pop"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/sample"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 0,
"end_s": 8,
"instrumental": False,
"version": "v5",
"tags": "upbeat pop"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/sample";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
start_s: 0,
end_s: 8,
instrumental: false,
version: "v5",
tags: "upbeat pop"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/sample"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 0,
"end_s": 8,
"instrumental": false,
"version": "v5",
"tags": "upbeat pop",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/sample";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 0,
"end_s": 8,
"instrumental": false,
"version": "v5",
"tags": "upbeat pop"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/sample";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"start_s" => 0,
"end_s" => 8,
"instrumental" => false,
"version" => "v5",
"tags" => "upbeat pop"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/sample")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
start_s: 0,
end_s: 8,
instrumental: false,
version: "v5",
tags: "upbeat pop"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/sample")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 0,
"end_s": 8,
"instrumental": false,
"version": "v5",
"tags": "upbeat pop"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/sample";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""start_s"": 0,
""end_s"": 8,
""instrumental"": false,
""version"": ""v5"",
""tags"": ""upbeat pop""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/sample";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"start_s\":0,"
"\"end_s\":8,"
"\"instrumental\":false,"
"\"version\":\"v5\","
"\"tags\":\"upbeat pop\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/sample"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"start_s": @0,
@"end_s": @8,
@"instrumental": @NO,
@"version": @"v5",
@"tags": @"upbeat pop"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/sample"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"start_s": 0,
"end_s": 8,
"instrumental": false,
"version": "v5",
"tags": "upbeat pop"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/sample');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'start_s': 0,
'end_s': 8,
'instrumental': false,
'version': 'v5',
'tags': 'upbeat pop'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/sample"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
start_s = 0,
end_s = 8,
instrumental = FALSE,
version = "v5",
tags = "upbeat pop"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
生成混搭 (mashup)
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
把歌曲做混搭再创作。
引用源音轨:需恰好 2 个 ,用 task_ids(长度 2 的数组)+ 可选 audio_indexes 指定
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :mashup 需要恰好 2 个源音轨 ——用 task_ids(长度为 2 的 task_id 数组)指定,可选 audio_indexes(与之平行的数组,指定各任务取 music[] 第几首,1-based,默认都取 1)。
custom 决定哪些字段生效:写在错误模式下的字段会被静默忽略 (不报错)。custom=true 时 prompt(歌词)、title、tags、negative_tags、auto_lyrics、style_weight、weirdness_constraint、audio_weight、persona_id 生效,gpt_description 被忽略;custom=false 时只读 gpt_description(此时必填 ,缺了提交期直接返回 400)。vocal_gender 两种模式都生效。不传 custom 时后端按此顺序推断:有 prompt → true;无 prompt 但有 gpt_description → false;否则有 tags/title → true。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
2 个源音轨所属任务的 task_id 数组(须恰好 2 个 ;数量不对提交期直接返回 400)。
与 task_ids 平行的数组,指定各任务取结果 music[] 第几首(1-based,默认都取 1)。
是否纯器乐(true=无人声);不传默认 false(要人声)。
生成版本:v3.5 / v4 / v4.5 / v4.5+ / v4.5-all / v5 / v5.5,影响音质与计费;不传默认 v5.5,非法值提交期直接返回 400。
true=自定义模式(用 prompt 作歌词);false=灵感模式(用 gpt_description);不传时按内容推断(见上方 Warning)。
歌词,custom=true 时生效(灵感模式下会被忽略)。
灵感提示词,custom=false 时必填 (缺了提交期直接 400、不扣费)。
标题。仅 custom=true 时生效 。
风格标签。仅 custom=true 时生效 。
要排除的风格标签。仅 custom=true 时生效 。
true=对输入歌词进行二次创作。仅 custom=true 时生效 。
风格权重,0.00–1.00(越界提交期直接返回 400)。仅 custom=true 时生效 。
创意权重,0.00–1.00(别名 weirdness)。仅 custom=true 时生效 。
音频权重,0.00–1.00。仅 custom=true 时生效 。
人声性别:Male / Female。两种模式都生效 。
Persona 风格 id。仅 custom=true 时生效 。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(音乐生成通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。完成后从 data.result.music[] 取 audio_url。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/mashup \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_ids": ["task_01ABC", "task_01DEF"],
"audio_indexes": [1, 2],
"custom": true,
"prompt": "upbeat mashup of the two tracks"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/mashup"
payload = {
"model": "suno",
"task_ids": ["task_01ABC", "task_01DEF"],
"audio_indexes": [1, 2],
"custom": True,
"prompt": "upbeat mashup of the two tracks"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/mashup";
const payload = {
model: "suno",
task_ids: ["task_01ABC", "task_01DEF"],
audio_indexes: [1, 2],
custom: true,
prompt: "upbeat mashup of the two tracks"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/mashup"
payload := map[string]interface{}{
"model": "suno",
"task_ids": []string{"task_01ABC", "task_01DEF"},
"audio_indexes": []int{1, 2},
"custom": true,
"prompt": "upbeat mashup of the two tracks",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/mashup";
String payload = """
{
"model": "suno",
"task_ids": ["task_01ABC", "task_01DEF"],
"audio_indexes": [1, 2],
"custom": true,
"prompt": "upbeat mashup of the two tracks"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/mashup";
$payload = [
"model" => "suno",
"task_ids" => ["task_01ABC", "task_01DEF"],
"audio_indexes" => [1, 2],
"custom" => true,
"prompt" => "upbeat mashup of the two tracks"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/mashup")
payload = {
model: "suno",
task_ids: ["task_01ABC", "task_01DEF"],
audio_indexes: [1, 2],
custom: true,
prompt: "upbeat mashup of the two tracks"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/mashup")!
let payload: [String: Any] = [
"model": "suno",
"task_ids": ["task_01ABC", "task_01DEF"],
"audio_indexes": [1, 2],
"custom": true,
"prompt": "upbeat mashup of the two tracks"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/mashup";
var payload = @"{
""model"": ""suno"",
""task_ids"": [""task_01ABC"", ""task_01DEF""],
""audio_indexes"": [1, 2],
""custom"": true,
""prompt"": ""upbeat mashup of the two tracks"""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/mashup";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_ids\":[\"task_01ABC\",\"task_01DEF\"],"
"\"audio_indexes\":[1,2],"
"\"custom\":true,"
"\"prompt\":\"upbeat mashup of the two tracks\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/mashup"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_ids": @[@"task_01ABC", @"task_01DEF"],
@"audio_indexes": @[@1, @2],
@"custom": @YES,
@"prompt": @"upbeat mashup of the two tracks"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/mashup"
let payload = {|{
"model": "suno",
"task_ids": ["task_01ABC", "task_01DEF"],
"audio_indexes": [1, 2],
"custom": true,
"prompt": "upbeat mashup of the two tracks"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/mashup');
final payload = {
'model': 'suno',
'task_ids': ['task_01ABC', 'task_01DEF'],
'audio_indexes': [1, 2],
'custom': true,
'prompt': 'upbeat mashup of the two tracks'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/mashup"
payload <- list(
model = "suno",
task_ids = c("task_01ABC", "task_01DEF"),
audio_indexes = c(1, 2),
custom = TRUE,
prompt = "upbeat mashup of the two tracks"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
创建语音
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
从音轨创建可复用音色。
引用源音轨:本端点不走 task_id + audio_index ,直接给一个可公开访问的 audio_url
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :本端点不走 task_id + audio_index ,需直接给一个可公开访问的 audio_url(系统据此提取音色)。缺失会返回 400 audio_url cannot be empty。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
源音轨的公网可访问 URL,系统据此提取音色。仅接受 MP3 / WAV。 缺失返回 400 audio_url cannot be empty。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。结果里含创建的音色信息。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/createVoice \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"audio_url": "https://example.com/source.mp3"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/createVoice"
payload = {
"model": "suno",
"audio_url": "https://example.com/source.mp3"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/createVoice";
const payload = {
model: "suno",
audio_url: "https://example.com/source.mp3"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/createVoice"
payload := map[string]interface{}{
"model": "suno",
"audio_url": "https://example.com/source.mp3",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/createVoice";
String payload = """
{
"model": "suno",
"audio_url": "https://example.com/source.mp3"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/createVoice";
$payload = [
"model" => "suno",
"audio_url" => "https://example.com/source.mp3"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/createVoice")
payload = {
model: "suno",
audio_url: "https://example.com/source.mp3"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/createVoice")!
let payload: [String: Any] = [
"model": "suno",
"audio_url": "https://example.com/source.mp3"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/createVoice";
var payload = @"{
""model"": ""suno"",
""audio_url"": ""https://example.com/source.mp3""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/createVoice";
const char *payload = "{"
"\"model\":\"suno\","
"\"audio_url\":\"https://example.com/source.mp3\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/createVoice"];
NSDictionary *payload = @{
@"model": @"suno",
@"audio_url": @"https://example.com/source.mp3"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/createVoice"
let payload = {|{
"model": "suno",
"audio_url": "https://example.com/source.mp3"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/createVoice');
final payload = {
'model': 'suno',
'audio_url': 'https://example.com/source.mp3'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/createVoice"
payload <- list(
model = "suno",
audio_url = "https://example.com/source.mp3"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
Persona
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
基于歌曲创建歌手 Persona,可绑定「提取 Vox」结果。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
Persona 名称;缺失直接返回 400。
描述。
风格。
「提取 Vox」得到的 id。
人声截取起点(秒)。引用 vox_audio_id 时,需与提取该 Vox 时的截取区间一致。
人声截取终点(秒)。引用 vox_audio_id 时,需与提取该 Vox 时的截取区间一致。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。结果里含 persona 信息。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/persona \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"name": "My Persona",
"styles": "pop"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/persona"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"name": "My Persona",
"styles": "pop"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/persona";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
name: "My Persona",
styles: "pop"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/persona"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"name": "My Persona",
"styles": "pop",
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/persona";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"name": "My Persona",
"styles": "pop"
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/persona";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"name" => "My Persona",
"styles" => "pop"
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/persona")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
name: "My Persona",
styles: "pop"
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/persona")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"name": "My Persona",
"styles": "pop"
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/persona";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""name"": ""My Persona"",
""styles"": ""pop""
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/persona";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"name\":\"My Persona\","
"\"styles\":\"pop\""
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/persona"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"name": @"My Persona",
@"styles": @"pop"
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/persona"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"name": "My Persona",
"styles": "pop"
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/persona');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'name': 'My Persona',
'styles': 'pop'
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/persona"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
name = "My Persona",
styles = "pop"
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
提取 Vox
计费说明 :按路径模型名计费(如 suno-generation);任务成功后按实际上游消耗结算(部分工具类按次),失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
从歌曲提取人声片段,产出可供 Persona 复用的 vox。
引用源音轨:task_id + audio_index 指定,无需记录任何额外 id
异步任务:提交返回 task_id,轮询 GET /v1/music/tasks/:task_id 获取结果
引用源音轨 :基于已有歌曲的操作无需记任何额外 id,只需传 task_id(产出源音轨那次任务的 task_id)+ audio_index(结果 music[] 里第几首,1-based,默认 1)。
本端点无版本维度 :不要传 version——传了会被丢弃、也不影响计费。
Authorizations
所有接口均需要使用Bearer Token进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
Body
音频模型。当前传 suno(不传默认 suno)。
产出源音轨那次任务的 task_id。缺失或无法解析源时提交期直接返回 400。
引用源任务结果 data.music[] 中的第几首(1-based;默认 1;一次生成通常 2 首:索引 1 与 2)。
截取起点(秒)。
截取终点(秒)。
获取结果 :本接口为异步任务。提交后拿到 task_id,按 3–5s 间隔轮询 GET /v1/music/tasks/{task_id},直到 status 为 completed 或 failed(通常 30–120s;生成中 status 为 pending,progress 排队 10 → 就绪 50 → 完成 100)。结果 id 可供 Persona 的 vox_audio_id 引用。失败时 data.error.message 给出原因,且预扣额度自动退回。
Response
响应状态码
返回数据数组
任务状态
submitted - 已提交
任务唯一标识符(用于轮询 GET /v1/music/tasks/{task_id} 获取结果)
Request
cURL Python JavaScript Go Java PHP Ruby Swift C# C Objective-C OCaml Dart R
cURL 复制
curl -X POST https://api.zhaotutu.ai/v1/music/generations/vox \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
--data '{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"vocal_start_s": 10,
"vocal_end_s": 30
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/vox"
payload = {
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"vocal_start_s": 10,
"vocal_end_s": 30
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/vox";
const payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
vocal_start_s: 10,
vocal_end_s: 30
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Go 复制
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://api.zhaotutu.ai/v1/music/generations/vox"
payload := map[string]interface{}{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"vocal_start_s": 10,
"vocal_end_s": 30,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer <token>")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Java 复制
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
public class Main {
public static void main(String[] args) throws Exception {
String url = "https://api.zhaotutu.ai/v1/music/generations/vox";
String payload = """
{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"vocal_start_s": 10,
"vocal_end_s": 30
}
""";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(payload))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}PHP 复制
<?php
$url = "https://api.zhaotutu.ai/v1/music/generations/vox";
$payload = [
"model" => "suno",
"task_id" => "task_01ABC",
"audio_index" => 1,
"vocal_start_s" => 10,
"vocal_end_s" => 30
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Authorization: Bearer <token>",
"Content-Type: application/json"
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Ruby 复制
require 'net/http'
require 'json'
require 'uri'
url = URI("https://api.zhaotutu.ai/v1/music/generations/vox")
payload = {
model: "suno",
task_id: "task_01ABC",
audio_index: 1,
vocal_start_s: 10,
vocal_end_s: 30
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = http.request(request)
puts response.bodySwift 复制
import Foundation
let url = URL(string: "https://api.zhaotutu.ai/v1/music/generations/vox")!
let payload: [String: Any] = [
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"vocal_start_s": 10,
"vocal_end_s": 30
]
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
print("Error: \(error)")
return
}
if let data = data, let responseString = String(data: data, encoding: .utf8) {
print(responseString)
}
}
task.resume()C# 复制
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var url = "https://api.zhaotutu.ai/v1/music/generations/vox";
var payload = @"{
""model"": ""suno"",
""task_id"": ""task_01ABC"",
""audio_index"": 1,
""vocal_start_s"": 10,
""vocal_end_s"": 30
}";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");
var content = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}C 复制
#include <stdio.h>
#include <curl/curl.h>
int main(void) {
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl) {
const char *url = "https://api.zhaotutu.ai/v1/music/generations/vox";
const char *payload = "{"
"\"model\":\"suno\","
"\"task_id\":\"task_01ABC\","
"\"audio_index\":1,"
"\"vocal_start_s\":10,"
"\"vocal_end_s\":30"
"}";
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer <token>");
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Objective-C 复制
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSURL *url = [NSURL URLWithString:@"https://api.zhaotutu.ai/v1/music/generations/vox"];
NSDictionary *payload = @{
@"model": @"suno",
@"task_id": @"task_01ABC",
@"audio_index": @1,
@"vocal_start_s": @10,
@"vocal_end_s": @30
};
NSError *error;
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
options:0
error:&error];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
[request setHTTPMethod:@"POST"];
[request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:jsonData];
NSURLSessionDataTask *task = [[NSURLSession sharedSession]
dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"Error: %@", error);
return;
}
NSString *result = [[NSString alloc] initWithData:data
encoding:NSUTF8StringEncoding];
NSLog(@"%@", result);
}];
[task resume];
[[NSRunLoop mainRunLoop] run];
}
return 0;
}OCaml 复制
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix
let url = "https://api.zhaotutu.ai/v1/music/generations/vox"
let payload = {|{
"model": "suno",
"task_id": "task_01ABC",
"audio_index": 1,
"vocal_start_s": 10,
"vocal_end_s": 30
}|}
let () =
let headers = Header.init ()
|> fun h -> Header.add h "Authorization" "Bearer <token>"
|> fun h -> Header.add h "Content-Type" "application/json"
in
let body = Cohttp_lwt.Body.of_string payload in
let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
print_endline body_str
in
Lwt_main.run responseDart 复制
import 'dart:convert';
import 'package:http/http.dart' as http;
void main() async {
final url = Uri.parse('https://api.zhaotutu.ai/v1/music/generations/vox');
final payload = {
'model': 'suno',
'task_id': 'task_01ABC',
'audio_index': 1,
'vocal_start_s': 10,
'vocal_end_s': 30
};
final response = await http.post(
url,
headers: {
'Authorization': 'Bearer <token>',
'Content-Type': 'application/json',
},
body: jsonEncode(payload),
);
print(response.body);
}R 复制
library(httr)
library(jsonlite)
url <- "https://api.zhaotutu.ai/v1/music/generations/vox"
payload <- list(
model = "suno",
task_id = "task_01ABC",
audio_index = 1,
vocal_start_s = 10,
vocal_end_s = 30
)
response <- POST(
url,
add_headers(
Authorization = "Bearer <token>",
`Content-Type` = "application/json"
),
body = toJSON(payload, auto_unbox = TRUE),
encode = "raw"
)
cat(content(response, "text"))
Response
200 400 401 402 403 429 500 502
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
}
]
}400 复制
{
"error": {
"code": 400,
"message": "请求参数无效",
"type": "invalid_request_error"
}
}401 复制
{
"error": {
"code": 401,
"message": "身份验证失败,请检查您的API密钥",
"type": "authentication_error"
}
}402 复制
{
"error": {
"code": 402,
"message": "账户余额不足,请充值后再试",
"type": "payment_required"
}
}403 复制
{
"error": {
"code": 403,
"message": "访问被禁止,您没有权限访问此资源",
"type": "permission_error"
}
}429 复制
{
"error": {
"code": 429,
"message": "请求过于频繁,请稍后再试",
"type": "rate_limit_error"
}
}500 复制
{
"error": {
"code": 500,
"message": "服务器内部错误,请稍后重试",
"type": "server_error"
}
}502 复制
{
"error": {
"code": 502,
"message": "网关错误,服务器暂时不可用",
"type": "bad_gateway"
}
}
生成音乐
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
Flow Music 文字生成音乐。支持风格提示词 / 歌词 / BPM / 时长控制,每次请求生成一首音乐
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
音乐风格或声音描述提示词
示例:"upbeat pop music with piano"
sound_prompt 与 lyrics 不可同时为空 (至少传一个)。每次请求仅生成一首音乐。
歌词文本,可先用生成歌词 接口获得后回填
示例:"[Verse 1]\n黑夜再长也会天亮\n..."
生成音乐标题
BPM(每分钟节拍数),必须 ≥ 1
示例:"120"
生成时长(秒)
支持范围:1 \~ 240 秒
随机种子,用于复现结果
相同的请求下传相同的 seed 值,会生成类似的结果,但不保证完全一致。
## 响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:纯风格提示词生成
{
"model": "flowmusic",
"title": "My Song",
"sound_prompt": "upbeat pop music with piano",
"bpm": "120",
"length": 60
}
场景 2:歌词 + 风格成曲
{
"model": "flowmusic",
"title": "坚持",
"lyrics": "[Verse 1]\n黑夜再长也会天亮\n...",
"sound_prompt": "energetic rock with electric guitar",
"length": 120
}
查询任务结果
音乐生成为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVB61E28THHFBSYXWA4FAJ",
"status": "completed",
"progress": 100,
"created": 1783413184,
"completed": 1783413236,
"actual_time": 52,
"cost": 0.048,
"credits_cost": 0.48,
"result": {
"music": [
{
"clip_id": "a41aade4-993e-4d28-b56f-d97e7ef7167c",
"title": "Regression Song",
"duration_seconds": "181.70666667",
"create_time": "2026-07-07T08:33:32.854073Z",
"lyrics": "[Verse 1]\nWaking up to the morning light,\n...",
"lyrics_id": "c302d603-81b6-552f-8122-e512928d6aa1",
"lyrics_timing_markers": [[10, 12], [212, 36]],
"audio_url": "https://cdn.example.com/audio/flowmusic_a41aade4.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_a41aade4.wav",
"image_url": "https://cdn.example.com/image/flowmusic_a41aade4_cover.jpg"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"title": "My Song",
"sound_prompt": "upbeat pop music with piano",
"bpm": "120",
"length": 60
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations"
payload = {
"model": "flowmusic",
"title": "My Song",
"sound_prompt": "upbeat pop music with piano",
"bpm": "120",
"length": 60
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations";
const payload = {
model: "flowmusic",
title: "My Song",
sound_prompt: "upbeat pop music with piano",
bpm: "120",
length: 60
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8AYYM6R03TGZ3Q2P0TZVNPX"
}
]
}400 复制
{
"error": {
"message": "sound_prompt and lyrics cannot both be empty",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
Lyria 3.5 生成音乐
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
使用 Lyria 3.5 进行 Flow Music 文字生成音乐,支持风格提示词、歌词、BPM 和时长控制
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
模型版本,固定传 "lyria-3.5"
Lyria 3.5 仍使用 flowmusic 作为模型名,不要将 model 改为 lyria-3.5 或 flowmusic-lyria-3.5。
音乐风格或声音描述提示词
示例:"upbeat pop music with piano"
sound_prompt 与 lyrics 不可同时为空 (至少传一个)。每次请求仅生成一首音乐。
歌词文本,可先用生成歌词 接口获得后回填
示例:"[Verse 1]\n黑夜再长也会天亮\n..."
生成音乐标题
BPM(每分钟节拍数),必须 ≥ 1
示例:"120"
生成时长(秒)
支持范围:1 \~ 240 秒
随机种子,用于复现结果
相同的请求下传相同的 seed 值,会生成类似的结果,但不保证完全一致。
## 响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:纯风格提示词生成
{
"model": "flowmusic",
"version": "lyria-3.5",
"title": "My Song",
"sound_prompt": "upbeat pop music with piano",
"bpm": "120",
"length": 60
}
场景 2:歌词 + 风格成曲
{
"model": "flowmusic",
"version": "lyria-3.5",
"title": "坚持",
"lyrics": "[Verse 1]\n黑夜再长也会天亮\n...",
"sound_prompt": "energetic rock with electric guitar",
"length": 120
}
查询任务结果
音乐生成为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVB61E28THHFBSYXWA4FAJ",
"status": "completed",
"progress": 100,
"created": 1783413184,
"completed": 1783413236,
"actual_time": 52,
"cost": 0.048,
"credits_cost": 0.48,
"result": {
"music": [
{
"clip_id": "a41aade4-993e-4d28-b56f-d97e7ef7167c",
"title": "Regression Song",
"duration_seconds": "181.70666667",
"create_time": "2026-07-07T08:33:32.854073Z",
"lyrics": "[Verse 1]\nWaking up to the morning light,\n...",
"lyrics_id": "c302d603-81b6-552f-8122-e512928d6aa1",
"lyrics_timing_markers": [[10, 12], [212, 36]],
"audio_url": "https://cdn.example.com/audio/flowmusic_a41aade4.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_a41aade4.wav",
"image_url": "https://cdn.example.com/image/flowmusic_a41aade4_cover.jpg"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"version": "lyria-3.5",
"title": "My Song",
"sound_prompt": "upbeat pop music with piano",
"bpm": "120",
"length": 60
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations"
payload = {
"model": "flowmusic",
"version": "lyria-3.5",
"title": "My Song",
"sound_prompt": "upbeat pop music with piano",
"bpm": "120",
"length": 60
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations";
const payload = {
model: "flowmusic",
version: "lyria-3.5",
title: "My Song",
sound_prompt: "upbeat pop music with piano",
bpm: "120",
length: 60
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01K8AYYM6R03TGZ3Q2P0TZVNPX"
}
]
}400 复制
{
"error": {
"message": "sound_prompt and lyrics cannot both be empty",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
生成歌词
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
Flow Music 根据提示词生成歌词。结果可回填到生成音乐接口的 lyrics 字段
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
生成歌词的提示词,≤ 3000 字符
建议描述歌曲主题、风格、情绪等,以获得更贴合的歌词
示例:"一首关于坚持的摇滚歌曲"
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:按主题生成歌词
{
"model": "flowmusic",
"prompt": "一首关于坚持的摇滚歌曲"
}
场景 2:歌词回填成曲
先生成歌词,完成后取 result.lyrics[0] 的 title 和 lyrics,回填到生成音乐 接口:
{
"model": "flowmusic",
"title": "坚持",
"lyrics": "[Verse 1]\n黑夜再长也会天亮\n...",
"sound_prompt": "energetic rock with electric guitar"
}
查询任务结果
歌词生成为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVCX91HYHSTHZ0NC1SRFW1",
"status": "completed",
"progress": 100,
"created": 1783413241,
"completed": 1783413284,
"actual_time": 43,
"cost": 0.016,
"credits_cost": 0.16,
"result": {
"lyrics": [
{
"title": "Bleached",
"lyrics": "[Intro]\n(Check)\n(One two)\n\n[Verse 1]\nThe birds are..."
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/lyrics \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"prompt": "一首关于坚持的摇滚歌曲"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/lyrics"
payload = {
"model": "flowmusic",
"prompt": "一首关于坚持的摇滚歌曲"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/lyrics";
const payload = {
model: "flowmusic",
prompt: "一首关于坚持的摇滚歌曲"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVCX91HYHSTHZ0NC1SRFW1"
}
]
}400 复制
{
"error": {
"message": "model is required",
"type": "invalid_request",
"param": "",
"code": "model_required"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
音乐延伸
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
Flow Music 对已生成的音频续写。从指定时间点开始,按编辑指令延伸音乐
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
源音乐 clip_id,来自已成功任务的 result.music[].clip_id
源任务必须已成功。外部音频可先通过上传音频 导入换取 clip_id。
开始续写的时间点(秒)
不能超过源 clip 时长
续写时长(秒)
最大值:164 秒
续写音乐的编辑指令
示例:"延续主歌旋律,加入弦乐"
续写后音乐标题
随机种子,用于复现结果
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:从副歌处续写 60 秒
{
"model": "flowmusic",
"clip_id": "abc123-def456",
"extend_from_s": 30,
"extend_s": 60,
"instruction": "延续主歌旋律,加入弦乐"
}
查询任务结果
音乐延伸为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。延伸产物是新的 clip_id,后续操作请使用新 clip_id。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVCYB70YJ1WY9X22RVYRNP",
"status": "completed",
"progress": 100,
"created": 1783413242,
"completed": 1783413292,
"actual_time": 50,
"cost": 0.048,
"credits_cost": 0.48,
"result": {
"music": [
{
"clip_id": "d2f589ea-5390-4e83-8e2f-4517420408fa",
"title": "Untitled (Extended)",
"duration_seconds": "39.95733333",
"create_time": "2026-07-07T08:34:33.240020Z",
"lyrics": "waking up to the morning light,\n...",
"lyrics_id": "0452451b-9e54-5d9f-8437-8bff97c7bbc8",
"lyrics_timing_markers": [[0, 12], [129, 20]],
"audio_url": "https://cdn.example.com/audio/flowmusic_d2f589ea.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_d2f589ea.wav",
"image_url": "https://cdn.example.com/image/flowmusic_d2f589ea_cover.jpg"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/extend \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"clip_id": "abc123-def456",
"extend_from_s": 30,
"extend_s": 60,
"instruction": "延续主歌旋律,加入弦乐"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/extend"
payload = {
"model": "flowmusic",
"clip_id": "abc123-def456",
"extend_from_s": 30,
"extend_s": 60,
"instruction": "延续主歌旋律,加入弦乐"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/extend";
const payload = {
model: "flowmusic",
clip_id: "abc123-def456",
extend_from_s: 30,
extend_s: 60,
instruction: "延续主歌旋律,加入弦乐"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVCYB70YJ1WY9X22RVYRNP"
}
]
}400 复制
{
"error": {
"message": "clip_id is required",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
Lyria 3.5 音乐延伸
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
使用 Lyria 3.5 从指定时间点延伸已生成的音乐
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
模型版本,固定传 "lyria-3.5"
Lyria 3.5 仍使用 flowmusic 作为模型名,不要将 model 改为 lyria-3.5 或 flowmusic-lyria-3.5。
源音乐 clip_id,来自已成功任务的 result.music[].clip_id
源任务必须已成功。外部音频可先通过上传音频 导入换取 clip_id。
开始续写的时间点(秒)
不能超过源 clip 时长
续写时长(秒)
最大值:164 秒
续写音乐的编辑指令
示例:"延续主歌旋律,加入弦乐"
续写后音乐标题
随机种子,用于复现结果
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:从副歌处续写 60 秒
{
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "abc123-def456",
"extend_from_s": 30,
"extend_s": 60,
"instruction": "延续主歌旋律,加入弦乐"
}
查询任务结果
音乐延伸为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。延伸产物是新的 clip_id,后续操作请使用新 clip_id。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVCYB70YJ1WY9X22RVYRNP",
"status": "completed",
"progress": 100,
"created": 1783413242,
"completed": 1783413292,
"actual_time": 50,
"cost": 0.048,
"credits_cost": 0.48,
"result": {
"music": [
{
"clip_id": "d2f589ea-5390-4e83-8e2f-4517420408fa",
"title": "Untitled (Extended)",
"duration_seconds": "39.95733333",
"create_time": "2026-07-07T08:34:33.240020Z",
"lyrics": "waking up to the morning light,\n...",
"lyrics_id": "0452451b-9e54-5d9f-8437-8bff97c7bbc8",
"lyrics_timing_markers": [[0, 12], [129, 20]],
"audio_url": "https://cdn.example.com/audio/flowmusic_d2f589ea.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_d2f589ea.wav",
"image_url": "https://cdn.example.com/image/flowmusic_d2f589ea_cover.jpg"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/extend \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "abc123-def456",
"extend_from_s": 30,
"extend_s": 60,
"instruction": "延续主歌旋律,加入弦乐"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/extend"
payload = {
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "abc123-def456",
"extend_from_s": 30,
"extend_s": 60,
"instruction": "延续主歌旋律,加入弦乐"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/extend";
const payload = {
model: "flowmusic",
version: "lyria-3.5",
clip_id: "abc123-def456",
extend_from_s: 30,
extend_s: 60,
instruction: "延续主歌旋律,加入弦乐"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVCYB70YJ1WY9X22RVYRNP"
}
]
}400 复制
{
"error": {
"message": "clip_id is required",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
片段替换
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
Flow Music 替换已生成音频中的某一段。按编辑指令重新生成 start_s 到 end_s 之间的片段
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
源音乐 clip_id,来自已成功任务的 result.music[].clip_id
替换开始时间(秒)
替换结束时间(秒)
end_s 必须大于 start_s,且不能超过源 clip 时长。
替换片段的编辑指令
示例:"替换为钢琴版本"
替换后音乐标题
随机种子,用于复现或控制生成结果
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:把 10-20 秒替换为钢琴版本
{
"model": "flowmusic",
"clip_id": "abc123-def456",
"start_s": 10,
"end_s": 20,
"instruction": "替换为钢琴版本"
}
查询任务结果
片段替换为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。替换产物是新的 clip_id(整首歌重新输出,其中指定区间已被替换),后续操作请使用新 clip_id。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVHGTG5JM33S8FG1K90YQ6",
"status": "completed",
"progress": 100,
"created": 1783413392,
"completed": 1783413454,
"actual_time": 62,
"cost": 0.048,
"credits_cost": 0.48,
"result": {
"music": [
{
"clip_id": "9508d1fe-633e-464b-8a40-c6368e5464fa",
"title": "Untitled (Replaced)",
"duration_seconds": "181.58933333",
"create_time": "2026-07-07T08:37:13.864452Z",
"lyrics": "[Verse 1]\nWaking up to the morning light,\n...",
"lyrics_id": "c302d603-81b6-552f-8122-e512928d6aa1",
"lyrics_timing_markers": [[10, 12], [71, 15]],
"audio_url": "https://cdn.example.com/audio/flowmusic_9508d1fe.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_9508d1fe.wav",
"image_url": "https://cdn.example.com/image/flowmusic_9508d1fe_cover.jpg"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/replace \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"clip_id": "abc123-def456",
"start_s": 10,
"end_s": 20,
"instruction": "替换为钢琴版本"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/replace"
payload = {
"model": "flowmusic",
"clip_id": "abc123-def456",
"start_s": 10,
"end_s": 20,
"instruction": "替换为钢琴版本"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/replace";
const payload = {
model: "flowmusic",
clip_id: "abc123-def456",
start_s: 10,
end_s: 20,
instruction: "替换为钢琴版本"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVHGTG5JM33S8FG1K90YQ6"
}
]
}400 复制
{
"error": {
"message": "end_s must be greater than start_s",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
Lyria 3.5 片段替换
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
使用 Lyria 3.5 替换已生成音频中的指定片段
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
模型版本,固定传 "lyria-3.5"
Lyria 3.5 仍使用 flowmusic 作为模型名,不要将 model 改为 lyria-3.5 或 flowmusic-lyria-3.5。
源音乐 clip_id,来自已成功任务的 result.music[].clip_id
替换开始时间(秒)
替换结束时间(秒)
end_s 必须大于 start_s,且不能超过源 clip 时长。
替换片段的编辑指令
示例:"替换为钢琴版本"
替换后音乐标题
随机种子,用于复现或控制生成结果
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:把 10-20 秒替换为钢琴版本
{
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "abc123-def456",
"start_s": 10,
"end_s": 20,
"instruction": "替换为钢琴版本"
}
查询任务结果
片段替换为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。替换产物是新的 clip_id(整首歌重新输出,其中指定区间已被替换),后续操作请使用新 clip_id。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVHGTG5JM33S8FG1K90YQ6",
"status": "completed",
"progress": 100,
"created": 1783413392,
"completed": 1783413454,
"actual_time": 62,
"cost": 0.048,
"credits_cost": 0.48,
"result": {
"music": [
{
"clip_id": "9508d1fe-633e-464b-8a40-c6368e5464fa",
"title": "Untitled (Replaced)",
"duration_seconds": "181.58933333",
"create_time": "2026-07-07T08:37:13.864452Z",
"lyrics": "[Verse 1]\nWaking up to the morning light,\n...",
"lyrics_id": "c302d603-81b6-552f-8122-e512928d6aa1",
"lyrics_timing_markers": [[10, 12], [71, 15]],
"audio_url": "https://cdn.example.com/audio/flowmusic_9508d1fe.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_9508d1fe.wav",
"image_url": "https://cdn.example.com/image/flowmusic_9508d1fe_cover.jpg"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/replace \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "abc123-def456",
"start_s": 10,
"end_s": 20,
"instruction": "替换为钢琴版本"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/replace"
payload = {
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "abc123-def456",
"start_s": 10,
"end_s": 20,
"instruction": "替换为钢琴版本"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/replace";
const payload = {
model: "flowmusic",
version: "lyria-3.5",
clip_id: "abc123-def456",
start_s: 10,
end_s: 20,
instruction: "替换为钢琴版本"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVHGTG5JM33S8FG1K90YQ6"
}
]
}400 复制
{
"error": {
"message": "end_s must be greater than start_s",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
Cover 改编
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
Flow Music 对整首歌做风格改编(翻唱 / 改风格),strength 控制编辑强度
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
源音乐的唯一标识符,来自已成功任务的 result.music[].clip_id
Cover 编辑指令
示例:"将这首歌曲改为爵士风格"
编辑强度
取值范围:0 \~ 1,越大改动越大
Cover 后的音乐标题
随机种子,用于结果复现
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:整曲改为爵士风格
{
"model": "flowmusic",
"clip_id": "abc123-def456",
"instruction": "将这首歌曲改为爵士风格",
"strength": 0.5
}
场景 2:外部音频导入后改编
先通过上传音频 把外部音频导入换取 clip_id,再做 Cover:
{
"model": "flowmusic",
"clip_id": "1db3a20f-4ddc-44e8-8c9c-6c9093c16ffe",
"instruction": "改成爵士风格",
"strength": 0.6
}
查询任务结果
Cover 改编为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。Cover 产物是新的 clip_id,后续操作请使用新 clip_id。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVD0E653EZ9FWD2SD9NNB6",
"status": "completed",
"progress": 100,
"created": 1783413244,
"completed": 1783413315,
"actual_time": 71,
"cost": 0.048,
"credits_cost": 0.48,
"result": {
"music": [
{
"clip_id": "ef3d804e-fa97-402f-ba17-4ff08270159b",
"title": "Untitled (Cover)",
"duration_seconds": "178.03733333",
"create_time": "2026-07-07T08:34:58.112190Z",
"lyrics": "[Verse 1]\nWaking up to the morning light,\n...",
"lyrics_id": "c302d603-81b6-552f-8122-e512928d6aa1",
"lyrics_timing_markers": [[10, 12], [212, 36]],
"audio_url": "https://cdn.example.com/audio/flowmusic_ef3d804e.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_ef3d804e.wav",
"image_url": "https://cdn.example.com/image/flowmusic_ef3d804e_cover.jpg"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/cover \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"clip_id": "abc123-def456",
"instruction": "将这首歌曲改为爵士风格",
"strength": 0.5
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/cover"
payload = {
"model": "flowmusic",
"clip_id": "abc123-def456",
"instruction": "将这首歌曲改为爵士风格",
"strength": 0.5
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/cover";
const payload = {
model: "flowmusic",
clip_id: "abc123-def456",
instruction: "将这首歌曲改为爵士风格",
strength: 0.5
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVD0E653EZ9FWD2SD9NNB6"
}
]
}400 复制
{
"error": {
"message": "strength must be between 0 and 1",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
Lyria 3.5 Cover 改编
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
使用 Lyria 3.5 对整首音乐进行风格改编
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
模型版本,固定传 "lyria-3.5"
Lyria 3.5 仍使用 flowmusic 作为模型名,不要将 model 改为 lyria-3.5 或 flowmusic-lyria-3.5。
源音乐的唯一标识符,来自已成功任务的 result.music[].clip_id
Cover 编辑指令
示例:"将这首歌曲改为爵士风格"
编辑强度
取值范围:0 \~ 1,越大改动越大
Cover 后的音乐标题
随机种子,用于结果复现
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:整曲改为爵士风格
{
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "abc123-def456",
"instruction": "将这首歌曲改为爵士风格",
"strength": 0.5
}
场景 2:外部音频导入后改编
先通过上传音频 把外部音频导入换取 clip_id,再做 Cover:
{
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "1db3a20f-4ddc-44e8-8c9c-6c9093c16ffe",
"instruction": "改成爵士风格",
"strength": 0.6
}
查询任务结果
Cover 改编为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。Cover 产物是新的 clip_id,后续操作请使用新 clip_id。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVD0E653EZ9FWD2SD9NNB6",
"status": "completed",
"progress": 100,
"created": 1783413244,
"completed": 1783413315,
"actual_time": 71,
"cost": 0.048,
"credits_cost": 0.48,
"result": {
"music": [
{
"clip_id": "ef3d804e-fa97-402f-ba17-4ff08270159b",
"title": "Untitled (Cover)",
"duration_seconds": "178.03733333",
"create_time": "2026-07-07T08:34:58.112190Z",
"lyrics": "[Verse 1]\nWaking up to the morning light,\n...",
"lyrics_id": "c302d603-81b6-552f-8122-e512928d6aa1",
"lyrics_timing_markers": [[10, 12], [212, 36]],
"audio_url": "https://cdn.example.com/audio/flowmusic_ef3d804e.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_ef3d804e.wav",
"image_url": "https://cdn.example.com/image/flowmusic_ef3d804e_cover.jpg"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/cover \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "abc123-def456",
"instruction": "将这首歌曲改为爵士风格",
"strength": 0.5
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/cover"
payload = {
"model": "flowmusic",
"version": "lyria-3.5",
"clip_id": "abc123-def456",
"instruction": "将这首歌曲改为爵士风格",
"strength": 0.5
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/cover";
const payload = {
model: "flowmusic",
version: "lyria-3.5",
clip_id: "abc123-def456",
instruction: "将这首歌曲改为爵士风格",
strength: 0.5
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVD0E653EZ9FWD2SD9NNB6"
}
]
}400 复制
{
"error": {
"message": "strength must be between 0 and 1",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
词曲分离
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
Flow Music 分离人声 / 伴奏音轨,结果为 zip 分轨包
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
需要分离音轨的音乐 clip_id,来自已成功任务的 result.music[].clip_id
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:分离人声与伴奏
{
"model": "flowmusic",
"clip_id": "abc123-def456"
}
查询任务结果
词曲分离为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。分离结果是一个 zip 打包文件 (result.music[0].file_url,约 20MB),内含人声 / 伴奏等分轨音频,提供下载即可。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVD1EFXYEHDJ8M0XNJ65AR",
"status": "completed",
"progress": 100,
"created": 1783413245,
"completed": 1783413331,
"actual_time": 86,
"cost": 0.048,
"credits_cost": 0.48,
"result": {
"music": [
{
"clip_id": "a41aade4-993e-4d28-b56f-d97e7ef7167c",
"file_url": "https://cdn.example.com/audio/flowmusic_a41aade4_stems.zip",
"url": "https://cdn.example.com/audio/flowmusic_a41aade4_stems.zip",
"mime_type": "application/zip",
"size_bytes": 20323367
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/stems \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"clip_id": "abc123-def456"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/stems"
payload = {
"model": "flowmusic",
"clip_id": "abc123-def456"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/stems";
const payload = {
model: "flowmusic",
clip_id: "abc123-def456"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVD1EFXYEHDJ8M0XNJ65AR"
}
]
}400 复制
{
"error": {
"message": "clip_id is required",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
上传音频
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
把外部音频导入 Flow Music,换取 clip_id 供后续延伸 / 替换 / Cover / 分离使用
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
待上传音频文件地址,需公网可访问
仅支持常见音频文件后缀(如 .mp3 / .wav)。
## 响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:导入外部音频换取 clip_id
{
"model": "flowmusic",
"audio_url": "https://example.com/audio.mp3"
}
完成后从 result.music[0].clip_id 取导入产物的 clip_id,即可用于延伸 / 替换 / Cover / 分离 。
查询任务结果
上传音频为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVD2FC61SYZ5103Z4XCCS5",
"status": "completed",
"progress": 100,
"created": 1783413246,
"completed": 1783413282,
"actual_time": 36,
"cost": 0.008,
"credits_cost": 0.08,
"result": {
"music": [
{
"clip_id": "1db3a20f-4ddc-44e8-8c9c-6c9093c16ffe",
"audio_url": "https://cdn.example.com/audio/flowmusic_1db3a20f_upload_audio.wav",
"url": "https://cdn.example.com/audio/flowmusic_1db3a20f_upload_audio.wav"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/upload-audio \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"audio_url": "https://example.com/audio.mp3"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/upload-audio"
payload = {
"model": "flowmusic",
"audio_url": "https://example.com/audio.mp3"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/upload-audio";
const payload = {
model: "flowmusic",
audio_url: "https://example.com/audio.mp3"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVD2FC61SYZ5103Z4XCCS5"
}
]
}400 复制
{
"error": {
"message": "audio_url is required",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
下载音频
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
Flow Music 将 clip 转出为指定格式(wav / mp3)的音频文件
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
需要下载的音乐 clip_id,来自已成功任务的 result.music[].clip_id
下载格式
可选值:
mp3 - 有损压缩,体积小
wav - 无损,适合后期制作
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:转出无损 wav
{
"model": "flowmusic",
"clip_id": "abc123-def456",
"format": "wav"
}
查询任务结果
下载音频为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。结果统一在 result.music[0].audio_url(url 同值),format / mime_type 字段标识实际格式。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVD3FPYYQPJ2N87XXE5NQG",
"status": "completed",
"progress": 100,
"created": 1783413247,
"completed": 1783413296,
"actual_time": 49,
"cost": 0.016,
"credits_cost": 0.16,
"result": {
"music": [
{
"clip_id": "a41aade4-993e-4d28-b56f-d97e7ef7167c",
"format": "wav",
"mime_type": "audio/wav",
"size_bytes": 34900726,
"audio_url": "https://cdn.example.com/audio/flowmusic_a41aade4_download_audio.wav",
"url": "https://cdn.example.com/audio/flowmusic_a41aade4_download_audio.wav"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/download-audio \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"clip_id": "abc123-def456",
"format": "wav"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/download-audio"
payload = {
"model": "flowmusic",
"clip_id": "abc123-def456",
"format": "wav"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/download-audio";
const payload = {
model: "flowmusic",
clip_id: "abc123-def456",
format: "wav"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVD3FPYYQPJ2N87XXE5NQG"
}
]
}400 复制
{
"error": {
"message": "format must be one of: wav, mp3",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
音乐视频渲染
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
Flow Music 按模板把音乐渲染成 mp4 视频,支持 simple / modern / player 三种预设
认证
所有接口均需要使用 Bearer Token 进行认证
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key
使用时在请求头中添加:
Authorization: Bearer YOUR_API_KEY
请求参数
模型名称,固定传 "flowmusic" (大小写不敏感)
需要生成视频的音乐 clip_id,来自已成功任务的 result.music[].clip_id
视频模板预设
可选值:
simple - 简洁模板
modern - 现代风格模板
player - 播放器风格模板
响应
响应状态码,成功时为 200
返回数据数组
任务状态,初始提交时为 submitted
任务唯一标识符,用于查询任务状态和结果
使用场景
场景 1:用 modern 模板渲染音乐视频
{
"model": "flowmusic",
"clip_id": "abc123-def456",
"preset": "modern"
}
查询任务结果
音乐视频渲染为异步任务,提交后会返回 task_id。使用 获取任务状态 接口查询生成进度和结果。结果在 result.music[0].video_url。
任务完成结果示例
查询返回示例 (GET /v1/music/tasks/{task_id}):
{
"code": 200,
"data": {
"id": "task_01KWXVD4HQEEY7B5NJ31177Q1H",
"status": "completed",
"progress": 100,
"created": 1783413248,
"completed": 1783413327,
"actual_time": 79,
"cost": 0.016,
"credits_cost": 0.16,
"result": {
"music": [
{
"clip_id": "a41aade4-993e-4d28-b56f-d97e7ef7167c",
"video_url": "https://cdn.example.com/video/flowmusic_a41aade4_video_clip.mp4",
"url": "https://cdn.example.com/video/flowmusic_a41aade4_video_clip.mp4"
}
]
}
}
}
Request
cURL Python JavaScript
cURL 复制
curl --request POST \
--url https://api.zhaotutu.ai/v1/music/generations/video-clip \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"model": "flowmusic",
"clip_id": "abc123-def456",
"preset": "modern"
}'Python 复制
import requests
url = "https://api.zhaotutu.ai/v1/music/generations/video-clip"
payload = {
"model": "flowmusic",
"clip_id": "abc123-def456",
"preset": "modern"
}
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())JavaScript 复制
const url = "https://api.zhaotutu.ai/v1/music/generations/video-clip";
const payload = {
model: "flowmusic",
clip_id: "abc123-def456",
preset: "modern"
};
const headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
};
fetch(url, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Response
200 400 403 429
200 复制
{
"code": 200,
"data": [
{
"status": "submitted",
"task_id": "task_01KWXVD4HQEEY7B5NJ31177Q1H"
}
]
}400 复制
{
"error": {
"message": "clip_id is required",
"type": "invalid_request",
"param": "",
"code": "invalid_request"
}
}403 复制
{
"error": {
"message": "余额不足",
"type": "invalid_request",
"param": "",
"code": "quota_not_enough"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
查询任务
计费说明 :按路径 SKU 计费(例如 flowmusic-generation);任务成功后按实际上游消耗结算,失败全额退款;金额以控制台预估 / 实扣为准。轮询 GET /v1/music/tasks/{task_id}。
查询 Flow Music 异步任务的执行状态、进度和生成结果
鉴权
所有 Flow Music 接口都需要 Bearer Token 鉴权
获取 API Key:
登录 控制台 →「API 令牌」获取 API Key。
添加到请求头:
Authorization: Bearer YOUR_API_KEY
路径参数
提交 Flow Music 任务后返回的任务 ID
任务 ID 来自提交接口响应中的 data[0].task_id。
## 查询参数
错误信息和部分提示文案的语言
可选值:zh、en、ja、ko
响应字段
响应状态码,成功时为 200
任务详情
任务 ID
任务状态:pending、processing、completed、failed
任务进度,范围 0-100
实际扣费金额;任务失败时通常为 0
实际消耗的 credits
任务完成后的生成结果;不同 Flow Music 能力返回的字段不同
结果结构
音乐类任务
生成音乐、音乐延伸、片段替换、Cover 改编、词曲分离、上传音频、下载音频和视频渲染通常返回 result.music 数组。
{
"result": {
"music": [
{
"clip_id": "a41aade4-993e-4d28-b56f-d97e7ef7167c",
"audio_url": "https://cdn.example.com/audio/flowmusic_a41aade4.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_a41aade4.wav",
"video_url": "https://cdn.example.com/video/flowmusic_a41aade4.mp4",
"file_url": "https://cdn.example.com/audio/flowmusic_a41aade4_stems.zip"
}
]
}
}
歌词任务
生成歌词返回 result.lyrics 数组。
{
"result": {
"lyrics": [
{
"title": "Bleached",
"lyrics": "[Intro]\n(Check)\n(One two)\n..."
}
]
}
}
使用说明
Flow Music 提交接口都是异步任务。提交成功后先获取 task_id,再调用本接口轮询任务状态;当 status 为 completed 时,从 result 中读取生成结果。
Request
cURL Python JavaScript
cURL 复制
curl --request GET \
--url https://api.zhaotutu.ai/v1/music/tasks/task_01K8AYYM6R03TGZ3Q2P0TZVNPX?language=zh \
--header 'Authorization: Bearer <token>'Python 复制
import requests
task_id = "task_01K8AYYM6R03TGZ3Q2P0TZVNPX"
url = f"https://api.zhaotutu.ai/v1/music/tasks/{task_id}"
headers = {
"Authorization": "Bearer <token>"
}
params = {
"language": "zh"
}
response = requests.get(url, headers=headers, params=params)
print(response.json())JavaScript 复制
const taskId = "task_01K8AYYM6R03TGZ3Q2P0TZVNPX";
const url = `https://api.zhaotutu.ai/v1/music/tasks/${taskId}?language=zh`;
const headers = {
"Authorization": "Bearer <token>"
};
fetch(url, {
method: "GET",
headers: headers
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error("Error:", error));
Response
200 404 429
200 复制
{
"code": 200,
"data": {
"id": "task_01K8AYYM6R03TGZ3Q2P0TZVNPX",
"status": "completed",
"progress": 100,
"created": 1783413241,
"completed": 1783413352,
"actual_time": 111,
"cost": 0.06,
"credits_cost": 0.6,
"result": {
"music": [
{
"clip_id": "a41aade4-993e-4d28-b56f-d97e7ef7167c",
"title": "My Song",
"duration_seconds": "181.70666667",
"audio_url": "https://cdn.example.com/audio/flowmusic_a41aade4.m4a",
"wav_url": "https://cdn.example.com/audio/flowmusic_a41aade4.wav"
}
]
}
}
}404 复制
{
"error": {
"message": "task not found",
"type": "invalid_request",
"param": "task_id",
"code": "task_not_found"
}
}429 复制
{
"error": {
"message": "当前分组容量饱和,请稍后重试",
"type": "rate_limit_error",
"param": "",
"code": "rate_limit_error"
}
}
常见问题
zhaotutu-image-g-v2-* 和 zhaotutu-image-g2-* 有什么区别?
是两套不同模型:参数、分辨率与计费均不同。扩展模型见 Zhaotutu 扩展 ;G-2 见模型列表中的 Zhaotutu Image G-2。
Midjourney 新接口和旧版 /mj/* 有什么区别?
新版走 /v1/midjourney/* (),计费 SKU 为 midjourney-*;旧版 /mj/* 是另一套 Discord 代理协议,请勿混用。
Suno 和 Seed Audio / Whisper 有什么区别?
完全不同路径:Suno 用 /v1/music/* ;Seed Audio 用 /v1/audio/generations;Whisper 用 /v1/audio/transcriptions。计费 SKU 看路径(suno-*),不是 body.model。详见 Suno 。
能直接用 OpenAI 官方 SDK 调用吗?
/v1/videos 接口对齐了 OpenAI Video API 的字段风格(prompt / status / metadata 等),但目前主流 OpenAI 官方 SDK 尚未开放 Video 相关方法,建议直接用 HTTP 客户端按本文档调用(见快速开始 的三语言示例)。
图生视频最多传几张图?
顶层 images 最多 2 张:第 1 张为首帧(必填),第 2 张为尾帧(可选)。JPG / JPEG / PNG / WEBP,单张 ≤ 30MB。
多模态模型(-multi)能同时传图片 + 视频 + 音频吗?
可以,把它们都放进 metadata.content 数组即可:图片最多 9 张、视频最多 3 个(MP4)、音频最多 3 个(MP3 / WAV),至少提供一种参考素材。注意此时不要再单独传顶层 images,它会被 content 整体覆盖。
参考素材怎么「上传」?
用 POST /v1/files/upload 上传文件,拿到 24 小时有效的直链 URL 后填入请求;也可以直接使用自己对象存储(COS / OSS / S3)的公网直链,详见参考素材指南 。
seconds 可以传任意秒数吗?
支持 "4" ~ "15" 的整数或 "-1"(自动时长),超出范围以上游返回的错误为准。
生成一个视频大概要多久?
通常在提交后 10~30 分钟内出结果,与档位、分辨率、时长和排队情况有关。请按 3~5 秒间隔轮询查询接口,不要依赖固定等待时间。
视频链接会过期吗?
会。metadata.url(视频)与 result_url(图片 / 音频)都是带签名有效期的临时地址,请在任务完成后及时下载并转存到自己的存储。
如何调用视频超分?
模型用 zhaotutu-upscaler,走 POST /v1/videos ;在 metadata.content 里传一条输入视频的 video_url,用 metadata.resolution 指定目标分辨率(720p / 1080p / 2k / 4k)。完整说明见 视频超分 。
如何调用 Seedream 图片生成?
使用 POST /v1/image/generations ,模型选 seedream-v5-pro-t2i(文生图)或 seedream-v5-pro-i2i(图生图,需传 images)。查询用 GET /v1/image/generations/{task_id} ,成功后读 data.result_url。
如何调用 Seed Audio 音频生成?
使用 POST /v1/audio/generations (不是同步 TTS /v1/audio/speech),模型 doubao-seed-audio-1.0。查询用 GET /v1/audio/generations/{task_id} ,成功后读 data.result_url。
如何调用 Whisper 语音转写?
使用 POST /v1/audio/transcriptions ,模型 whisper-1,multipart 上传音频后同步返回文本。按时长计费(1 分钟 = 1000 tokens)。勿与异步 Seed Audio /v1/audio/generations 混淆。
图片的 resolution 和 width/height 怎么选?
传了 metadata.resolution(1k / 2k)时优先用它,忽略宽高;不传 resolution 时可自定义 width / height(240~8192)。