> ## Documentation Index
> Fetch the complete documentation index at: https://docs.laozhang.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Seedream API：画像生成・編集の料金と使い方

> LaoZhang APIでSeedream 5.0 Flash（1枚$0.018から）、5.0 Pro、5.0、4.5、4.0を呼び出し、最大10枚の参照画像を使った編集や透過レイヤーへの分解を行う手順です。

Seedream 5.0 Flashは最新で最も安いSeedreamモデル、5.0 Proは画質が最も高いモデルです。生成も複数画像の合成も1つのJSONエンドポイントで行い、出力画像1枚ごとに課金されます。

参照画像は課金されません。例外は5.0 Proで、2枚目以降の参照画像1枚につき\$0.003かかります。2026年9月25日時点の公開価格は次のとおりです（[AIモデルのAPI料金一覧](https://docs.laozhang.ai/ja/models.md)を参照）。

| モデルID | バージョン | 1枚あたりの料金 |
| - | - | - |
| `seedream-5-0-flash-260915` | Seedream 5.0 Flash（最新） | \$0.018 |
| `seedream-5-0-pro-260628` | Seedream 5.0 Pro | \$0.12 |
| `seedream-5-0-260128` | Seedream 5.0 | \$0.035 |
| `seedream-4-5-251128` | Seedream 4.5 | \$0.045 |
| `seedream-4-0-250828` | Seedream 4.0 | \$0.035 |

Seedreamのリクエストは、すべて同じエンドポイントとJSONボディを使います。

* エンドポイント：`POST https://api.laozhang.ai/v1/images/generations`
* 画像を生成するときは、プロンプトを送ります。
* 画像を編集・合成するときは、`image` に1〜10枚の参照画像を追加します。
* 同時リクエスト：プラットフォーム側の上限やスロットリングはありません。`429` は上流の処理能力によるものです。詳しくは[同時リクエストと429](https://docs.laozhang.ai/ja/faq/api-concurrency.md)を参照してください。

![Seedream 5.0で生成した、山に沈む夕日のリアルな画像](https://mintcdn.com/laozhangai-edd05f2c/YuJHjB7ivlJQODe0/images/samples/seedream-generate.jpg?fit=max\&auto=format\&n=YuJHjB7ivlJQODe0\&q=85\&s=58c254e27cd42e2b29f5a2cbf1efba30)

下の生成例の出力：Seedream 5.0、2K。プロンプト：A beautiful sunset over mountains, realistic style

このページの例は、Seedream 5.0（`seedream-5-0-260128`）を使います。ほかのバージョンを呼び出す場合は次のとおりです。

* **4.5または4.0**：`model` を変更します。
* **5.0 Flashまたは5.0 Pro**：`model` を変更し、リクエストに `sequential_image_generation` と `stream` が含まれていないことを確認します。この2モデルは、これらのフィールドがあるとHTTP 400を返します。下の編集例は `"sequential_image_generation": "disabled"` を送っているため、先にその行を削除してください。

## 始める前に

**1. 回数課金のモデルに使えるキーを作成する**

Seedreamは回数課金のモデルです。[トークン管理](https://api.laozhang.ai/token)でキーを作成（または既存のキーを編集）し、**課金方式**（计费模式）を**従量優先**（按量优先、推奨）または**回数課金**（按次计费）にします。従量優先のキーは従量課金のモデルも呼び出せますが、回数課金のキーが呼び出せるのは回数課金のモデルだけです。

キーはサーバー側の環境変数に保存してください。

![トークン管理で、課金方式を回数課金（按次计费）にしてトークンを作成する画面](https://mintcdn.com/laozhangai-edd05f2c/_loZ0Jy0ZI__xJ9z/images/token-create-per-request.png?fit=max\&auto=format\&n=_loZ0Jy0ZI__xJ9z\&q=85\&s=1fdceb804bb3ad50f83a21ec65b4d807)

**2. 環境を準備する**

キーを環境変数に設定し、Pythonの例で使う `requests` をインストールします。

```bash theme={null}
export LAOZHANG_API_KEY="YOUR_LAOZHANG_API_KEY"
python3 -m pip install requests
```

## 画像を生成する

ウォーターマークなしの2K画像を生成し、レスポンスを `seedream-generation.json` に書き出すリクエストです。

```bash theme={null}
curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-0-260128",
    "prompt": "A beautiful sunset over mountains, realistic style",
    "size": "2K",
    "response_format": "url",
    "watermark": false
  }' \
  -o seedream-generation.json
```

成功すると、画像が `data` に入って返ります。

```json theme={null}
{
  "created": 1726051200,
  "data": [
    {
      "url": "https://example.com/generated_image.jpg"
    }
  ]
}
```

### 結果を保存する

レスポンスを受け取ったら、すぐに画像をダウンロードしてください。次のスクリプトを `save_images.py` として保存します。レスポンス内の画像が `url` でも `b64_json` でも、すべて保存します。

```python save_images.py theme={null}
import base64
import json
import sys
import urllib.request
from pathlib import Path

response_file, stem = sys.argv[1], sys.argv[2]
response = json.loads(Path(response_file).read_text())
if not response.get("data"):
    sys.exit(f"{response_file} に画像がありません: {response}")

for number, item in enumerate(response["data"], start=1):
    if item.get("b64_json"):
        # data:image/...;base64, のプレフィックスがあれば取り除き、欠けたパディングを補う
        value = item["b64_json"].split(",", 1)[-1]
        image = base64.b64decode(value + "=" * (-len(value) % 4))
    else:
        with urllib.request.urlopen(item["url"], timeout=120) as download:
            image = download.read()
    if image.startswith(b"\x89PNG"):
        extension = "png"
    elif image[:4] == b"RIFF" and image[8:12] == b"WEBP":
        extension = "webp"
    else:
        extension = "jpg"
    path = Path(f"{stem}-{number}.{extension}")
    path.write_bytes(image)
    print(f"保存しました: {path}")
```

```bash theme={null}
python3 save_images.py seedream-generation.json seedream-sunset
```

`保存しました: seedream-sunset-1.jpg` のような行が表示されます。ファイルを開いて結果を確認してください。

### Pythonで生成する

```python theme={null}
import base64
import os
from pathlib import Path

import requests

response = requests.post(
    "https://api.laozhang.ai/v1/images/generations",
    headers={"Authorization": f"Bearer {os.environ['LAOZHANG_API_KEY']}"},
    json={
        "model": "seedream-5-0-260128",
        "prompt": "A beautiful sunset over mountains, realistic style",
        "size": "2K",
        "response_format": "url",
        "watermark": False,
    },
    timeout=180,
)
response.raise_for_status()
item = response.json()["data"][0]

if item.get("b64_json"):
    value = item["b64_json"].split(",", 1)[-1]
    image = base64.b64decode(value + "=" * (-len(value) % 4))
else:
    download = requests.get(item["url"], timeout=120)
    download.raise_for_status()
    image = download.content

extension = "png" if image.startswith(b"\x89PNG") else "jpg"
output = Path(f"seedream-sunset.{extension}")
output.write_bytes(image)
print(f"保存しました: {output}")
```

## 画像を編集する

既存の画像を編集・描き直すときは、リクエストに `image` を追加します。この例はBytePlusのドキュメントにある公開サンプル画像を使うため、そのまま実行できます。

```bash theme={null}
curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-0-260128",
    "prompt": "青々とした芝生に寝そべる犬のクローズアップ画像を生成してください。",
    "image": "https://ark-doc.tos-ap-southeast-1.bytepluses.com/doc_image/seedream4_imageToimage.png",
    "sequential_image_generation": "disabled",
    "size": "2K",
    "response_format": "url",
    "watermark": false
  }' \
  -o seedream-edit.json

python3 save_images.py seedream-edit.json seedream-edit
```

## 最大10枚の参照画像を合成する

複数の参照画像を使うときは、`image` を配列で渡します。各要素は公開URLか、`data:image/png;base64,...` のようなデータURLです。画像は配列の順に番号が付くため、プロンプトでは「画像1」「画像2」のように指定できます。

ローカルの3つのファイルをデータURLとして送る例です。

```bash theme={null}
IMG1=$(base64 < product.png | tr -d '\n')
IMG2=$(base64 < scene.jpg | tr -d '\n')
IMG3=$(base64 < style.jpg | tr -d '\n')

curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @- \
  -o seedream-multi-edit.json <<EOF
{
  "model": "seedream-5-0-260128",
  "prompt": "画像1の商品を画像2のシーンに置き、画像3のライティングと色調を適用してください。商品の形、ラベル、色はそのまま保ってください。",
  "image": [
    "data:image/png;base64,$IMG1",
    "data:image/jpeg;base64,$IMG2",
    "data:image/jpeg;base64,$IMG3"
  ],
  "sequential_image_generation": "disabled",
  "size": "2K",
  "response_format": "url",
  "watermark": false
}
EOF

python3 save_images.py seedream-multi-edit.json seedream-multi-edit
```

### Pythonで参照画像を合成する

次の関数は1〜10枚の参照画像を受け取り、ローカルファイルはデータURLに変換し、公開URLはそのまま渡します。

```python theme={null}
import base64
import mimetypes
import os
from pathlib import Path

import requests

API_URL = "https://api.laozhang.ai/v1/images/generations"
HEADERS = {"Authorization": f"Bearer {os.environ['LAOZHANG_API_KEY']}"}


def to_image_input(source):
    """URLはそのまま返し、ローカルファイルはデータURLに変換する。"""
    if source.startswith(("https://", "http://", "data:")):
        return source
    path = Path(source)
    mime_type = mimetypes.guess_type(path.name)[0] or "image/png"
    encoded = base64.b64encode(path.read_bytes()).decode("ascii")
    return f"data:{mime_type};base64,{encoded}"


def seedream_edit(prompt, sources, model="seedream-5-0-260128"):
    if not 1 <= len(sources) <= 10:
        raise ValueError("Seedreamの参照画像は1〜10枚です")
    images = [to_image_input(source) for source in sources]
    response = requests.post(
        API_URL,
        headers=HEADERS,
        json={
            "model": model,
            "prompt": prompt,
            "image": images[0] if len(images) == 1 else images,
            "sequential_image_generation": "disabled",
            "size": "2K",
            "response_format": "url",
            "watermark": False,
        },
        timeout=180,
    )
    response.raise_for_status()
    return response.json()


def save_all_images(result, stem):
    """data[] の全要素を保存する。連続生成では複数の画像が返ることがある。"""
    paths = []
    for number, item in enumerate(result["data"], start=1):
        if item.get("b64_json"):
            value = item["b64_json"].split(",", 1)[-1]
            image = base64.b64decode(value + "=" * (-len(value) % 4))
        else:
            download = requests.get(item["url"], timeout=120)
            download.raise_for_status()
            image = download.content
        extension = "png" if image.startswith(b"\x89PNG") else "jpg"
        path = Path(f"{stem}-{number}.{extension}")
        path.write_bytes(image)
        paths.append(path)
    return paths


result = seedream_edit(
    "画像1の商品を画像2のシーンに置き、画像3のライティングと色調を適用してください。"
    "商品の形、ラベル、色はそのまま保ってください。",
    ["product.png", "scene.jpg", "style.jpg"],
)
for path in save_all_images(result, "seedream-python-edit"):
    print("保存しました:", path)
```

## 画像を透過レイヤーに分解する

Seedream 5.0 Flash（`seedream-5-0-flash-260915`）と5.0 Pro（`seedream-5-0-pro-260628`）は、完成した1枚の画像を、背景と要素ごとの透過PNGレイヤーに分解できます。背景の差し替え、レイアウトの組み替え、要素の再利用に使えます。

どちらのモデルも返した画像すべてに課金され、Proの1枚あたりの料金はFlashの約6.7倍なので、まずFlashで試してください。通常のプロンプトで透過背景を指示してもアルファチャンネルは付きません。透過が必要なときはレイヤー分解を使います。

レイヤー分解のリクエストは、通常の編集と次の点が異なります。

* `layer_decomposition` を `true` にします。
* `image` には画像をちょうど1枚、文字列または要素1つの配列で送ります。
* `prompt` は任意です。省略するか空文字列にすると、モデルが主な要素を自動で検出します。
* `size` は `1K` にします。ピクセル数の直接指定は使えません。
* レイヤー分解で使える解像度は、`1K`、`1.5K`、`2K`、`auto` だけです。
* 対応は5.0 Flashと5.0 Proのみです。`seedream-5-0-260128` と `seedream-4-5-251128` では、エラーコード `InvalidParameter` のHTTP 400が返ります。

### レイヤー分解のリクエストを送る

```bash theme={null}
curl --fail-with-body --max-time 360 "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-0-flash-260915",
    "image": "https://example.com/your-poster.jpg",
    "layer_decomposition": true,
    "size": "1K",
    "response_format": "url",
    "watermark": false
  }' \
  -o seedream-layers.json
```

`image` のURLは、公開ダウンロードできる自分の画像に置き換えるか、データURLを渡してください。5.0 Proを使うときは `model` だけを変更します。

> [!WARNING]
>
> **レイヤー分解は、返した画像1枚ごとに課金されます。Flashは1枚\$0.018、Proは1枚\$0.12です。**
>
> * 返すレイヤーの数はモデルが決め、同じ画像でも実行ごとに変わることがあります。映画のポスターが6枚（背景1枚とレイヤー5枚）に分かれた場合、Flashで\$0.108、Proで\$0.72です。要素の多い画像では十数枚以上になることもあり、Flashで16枚なら\$0.288です。
> * `1K` で6枚の結果なら、Flashは1分以内、Proは約70秒かかり、レイヤーが多いほど長くなります。クライアントのタイムアウトは300秒以上にしてください。2Kのリクエストは長時間かかることがあり、クライアントが切断しても課金されます。
> * 分解できない画像では、HTTP 400が返り、課金されません。再試行できます。
> * 取り除いた要素の背後の領域はモデルが描き足すため、商用利用の前に背景を確認してください。

### レイヤーのレスポンスを読む

`data[]` の最初の要素が背景で、残りの各要素が1つのレイヤーです。次のレスポンスは、背景とレイヤー1つだけに省略しています。

```json theme={null}
{
  "data": [
    {
      "url": "https://example.com/base.jpeg",
      "size": "896x1200",
      "output_format": "jpeg",
      "z_index": 0
    },
    {
      "url": "https://example.com/layer.png",
      "size": "916x529",
      "output_format": "png",
      "z_index": 4,
      "bounding_box": {
        "absolute": [260, 716, 619, 924],
        "normalized": [290, 597, 690, 769]
      },
      "name": "Spaceship",
      "description": "Sci-fi spaceship with blue engine glow effects, separate from the background nebula."
    }
  ],
  "usage": {
    "input_images": 1,
    "generated_images": 6
  }
}
```

| フィールド | 意味 |
| - | - |
| `url` | 一時的なダウンロードリンク。早めに保存する。CORSヘッダーが付かないため、ブラウザーのクライアントでは `"response_format": "b64_json"` を指定し、各画像を `b64_json` から読み取る |
| `size` | この画像ファイルのピクセルサイズ |
| `output_format` | 背景はリクエストの `output_format`（既定値は `jpeg`）に従う。レイヤーは常にRGBAの `png` |
| `z_index` | 重なり順。背景が0で、レイヤーは1から順に大きくなり、値が大きいほど手前 |
| `bounding_box.absolute` | 背景上のレイヤーの位置。背景のピクセル単位の `[left, top, right, bottom]` |
| `bounding_box.normalized` | 同じ範囲を0〜1000のスケールで表したもの |
| `name`、`description` | モデルが各レイヤーに付ける英語のラベルと説明。背景には付かない |
| `usage.generated_images` | 返した画像の数（背景を含む） |

`usage` には `output_tokens` も含まれますが、課金額は画像の枚数だけで決まります。

レイヤーのファイルサイズは、バウンディングボックスの大きさと一致するとは限りません。例では916×529のPNGが359×208のボックスに入るため、画像を組み立て直すときは各レイヤーを `absolute` のボックスに合わせて拡大・縮小してください。

### レイヤーを保存して画像を組み立て直す

次のスクリプトは `seedream-layers.json` を読み、各画像を `z_index` と名前を含むファイル名で保存します。さらにPillowで、各レイヤーを背景上の `bounding_box.absolute` の位置に貼り付けます。先に `python3 -m pip install pillow` でPillowをインストールしてください。

```python save_layers.py theme={null}
import json
import re
import sys
import urllib.request
from io import BytesIO
from pathlib import Path

from PIL import Image

response = json.loads(Path(sys.argv[1]).read_text())
canvas = None

# z_index の小さい順：最初に背景、その上に各レイヤーを重ねる
for item in sorted(response["data"], key=lambda item: item["z_index"]):
    with urllib.request.urlopen(item["url"], timeout=120) as download:
        content = download.read()
    name = re.sub(r"[^a-z0-9]+", "-", item.get("name", "base").lower()).strip("-")
    extension = "png" if item["output_format"] == "png" else "jpg"
    path = Path(f"layer-{item['z_index']:02d}-{name or 'layer'}.{extension}")
    path.write_bytes(content)
    print(f"保存しました: {path}")

    image = Image.open(BytesIO(content)).convert("RGBA")
    if "bounding_box" not in item:
        canvas = image  # 背景には bounding_box がない
        continue
    left, top, right, bottom = item["bounding_box"]["absolute"]
    layer = image.resize((right - left, bottom - top), Image.LANCZOS)
    canvas.alpha_composite(layer, (left, top))

canvas.save("recomposited.png")
print("保存しました: recomposited.png")
```

```bash theme={null}
python3 save_layers.py seedream-layers.json
```

`layer-00-base.jpg` や `layer-04-spaceship.png` などのファイルと、`recomposited.png` ができます。背景を変えたり要素を外したりするときは、合成の前に背景ファイルを差し替えるか、そのレイヤーを飛ばしてください。

## パラメーター

| パラメーター | 型 | 必須 | 説明 |
| - | - | - | - |
| `model` | string | 必須 | このページ冒頭の表にあるモデルID。例：`seedream-5-0-flash-260915`、`seedream-5-0-260128` |
| `prompt` | string | 必須 | 画像の説明または編集の指示。レイヤー分解では任意 |
| `image` | string または array | 編集時 | 参照画像1枚なら文字列、最大10枚なら配列。各要素は公開URLかデータURL。レイヤー分解ではちょうど1枚 |
| `size` | string | 任意 | 出力サイズ。例では `2K`。使える値はモデルごとに異なる（下の「よくある質問」を参照） |
| `response_format` | string | 任意 | `url`（既定値）または `b64_json` |
| `output_format` | string | 任意 | 5.0 Flash、5.0 Pro、5.0で `png` または `jpeg`。レイヤー分解では背景の形式だけに適用 |
| `watermark` | boolean | 任意 | `false` でウォーターマークなし |
| `sequential_image_generation` | string | 任意 | `disabled`（既定値）は例のとおり1枚を返す。`auto` は連続生成で、返す枚数をモデルが決める（下の「よくある質問」を参照）。5.0 Flashと5.0 Proは非対応 |
| `layer_decomposition` | boolean | 任意 | 5.0 Flashと5.0 Pro。`true` で参照画像1枚を背景と透過レイヤーに分解する（上の「画像を透過レイヤーに分解する」を参照） |

5.0 Flashと5.0 Proは、リクエストに `sequential_image_generation`（`"disabled"` でも）や `stream` があるとHTTP 400を返します。また `n` を無視するため、レイヤー分解以外では1回のリクエストで1枚が返ります。

連続生成とレイヤー分解では、1つのレスポンスに複数の画像が入ることがあります。`save_images.py`、`save_all_images`、`save_layers.py` と同じように、`data[]` の全要素を保存してください。

## よくある質問

### どのSeedreamのバージョンを使えばよいですか？

タスクに必要なものから選びます。

* **低価格、速さ、大量生成**：Seedream 5.0 Flash（`seedream-5-0-flash-260915`）、1枚\$0.018。BytePlusは、広告クリエイティブ、商品画像、文字入りのポスターやデザイン向けと位置づけています。
* **最高画質**：Seedream 5.0 Pro（`seedream-5-0-pro-260628`）。リアルな人物写真、素材の細かな質感、複雑な指示に向きます。1枚\$0.12で5.0の約3.4倍の料金がかかり、処理も遅いため、日常的な用途には5.0かFlashを使ってください。
* **3K出力、連続生成、ストリーミング**：Seedream 5.0（`seedream-5-0-260128`）。BytePlusのドキュメントではSeedream 5.0 liteと呼ばれ、`2K` と `3K` の出力に対応します（最大3K）。
* **4K**：Seedream 4.5（`seedream-4-5-251128`）または4.0（`seedream-4-0-250828`）。それ以外の用途では、既存のワークフローがこの2つの出力に依存している場合にだけ使い続けてください。
* **既存画像からの透過レイヤー**：5.0 Flashのレイヤー分解（上の「画像を透過レイヤーに分解する」を参照）。5.0 Proも対応していますが、1枚あたりの料金は約6.7倍です。

各バージョンの最新の価格は、[AIモデルのAPI料金一覧](https://docs.laozhang.ai/ja/models.md)で確認できます。

### `size` に使える値と4Kの可否

指定方法は2通りあり、どちらか一方だけを使います。解像度の段階を指定してアスペクト比をプロンプトで説明する（例：「16:9の横長」）か、`2848x1600` のようにピクセル数を直接指定します。モデルごとに使える解像度の段階は次のとおりです。

* `seedream-5-0-flash-260915`：`1K`、`1.5K`、`2K`（既定値は2K）
* `seedream-5-0-pro-260628`：`1K`、`2K`
* `seedream-5-0-260128`：`2K`、`3K`（最大3K）
* `seedream-4-5-251128`：`2K`、`4K`
* `seedream-4-0-250828`：`1K`、`2K`、`4K`

ピクセル数を直接指定する場合は、総ピクセル数とアスペクト比の両方が範囲内である必要があります。

* 最小：5.0と4.5は2560×1440（3,686,400ピクセル）、4.0は1280×720（921,600ピクセル）。
* 最大：4.5と4.0は4096×4096、5.0は3Kの段階まで。
* 5.0 Flash：総ピクセル数921,600〜4,624,220。
* 5.0 Pro：最大約419万ピクセル。例：`2048x2048`、16:9なら `2720x1530`。
* アスペクト比：5.0 Flash、5.0、4.5、4.0で1/16〜16。

このため、`1024x1024` のような小さいサイズは5.0と4.5で失敗します。5.0 Flashは解像度の段階を指定すると内容からアスペクト比を決めるため、比率を固定したいときは `2560x1440` のようにピクセル数を指定してください。

5.0 Flashで `3K` や `4K` を指定するとHTTP 400が返ります。1枚あたりの料金はサイズによって変わりません。

レイヤー分解で使えるのは `1K`、`1.5K`、`2K`、`auto` だけで、ピクセル数は指定できません。

### 連続生成の仕組みと課金

`sequential_image_generation` を `auto` にすると、モデルがプロンプトから、関連する画像を何枚返すかを決めます。たとえば「同じキャラクターの朝・昼・夜の画像を3枚」のような指示です。

枚数の上限を決めたいときは、BytePlusが公開している `sequential_image_generation_options.max_images`（1〜15）を使います。参照画像と生成画像の合計は15枚を超えられません。

このときレスポンスの `data[]` には複数の画像が入るため、すべての要素を保存してください。返った画像1枚ごとに課金され、`seedream-5-0-260128` で4枚なら\$0.14です。参照画像は課金されません。実際の課金額は[呼び出しログ](https://docs.laozhang.ai/en/faq/call-logs.md)で確認できます。

5.0 Flashと5.0 Proは連続生成に対応していません。`"disabled"` を含め、`sequential_image_generation` の値を送るとHTTP 400が返ります。連続生成には5.0を使うか、FlashやProに1枚ずつリクエストを送ってください。

### ローカル画像の送り方と制限

`data:image/png;base64,<Base64データ>` の形式のデータURLに変換します。形式名は `png` や `jpeg` のように小文字で書きます。上の「Pythonで参照画像を合成する」のヘルパーが、この変換を行います。

BytePlusは、参照画像1枚ごとに次の制限を設けています。

* 形式：jpeg、png、webp、bmp、tiff、gif、heic、heif
* サイズ：30 MBまで
* 寸法：幅と高さがそれぞれ14ピクセルより大きく、総ピクセル数が6000×6000以下
* アスペクト比：1/16〜16

公開URLは、直接ダウンロードできる必要があります。Base64にするとリクエストボディが約3分の1大きくなるため、大きな画像には公開URLを使ってください。

### ウォーターマークを消すには？

このページの例と同じく、`"watermark": false` を送ります。BytePlusでは `watermark` の既定値が `true` で、右下に「AI generated」のラベルが入ります。ラベルのない画像が必要なときは、明示的に `false` を指定してください。

### 結果URLの有効期間とBase64での受け取り

BytePlusによると、画像のURLは生成から24時間有効です。レスポンスを受け取ったらすぐ画像をダウンロードして自分で保管し、返されたURLを恒久的なアドレスとして保存しないでください。

画像をレスポンス内で受け取るには、`response_format` を `b64_json` にします。`save_images.py` とPythonの例は、どちらの形式にも対応しています。

### 失敗したリクエストは課金されますか？

いいえ。パラメーターエラーやモデレーションによるブロックなど、200以外のレスポンスは課金されません。課金されるのは画像が返ったときだけです。

クライアントのタイムアウトは失敗と同じではありません。サーバー側では処理が完了して課金されている可能性があるため、再送する前に[呼び出しログ](https://docs.laozhang.ai/en/faq/call-logs.md)を確認してください。実際の課金額は呼び出しログの記録が最終的なものです。

処理中のリクエストを途中で切らないよう、クライアントのタイムアウトはモデルに合わせて設定します。

* 5.0 Flash：60秒以上。BytePlusによると20秒以内に完了し、参照画像が10枚なら約30秒です。
* 5.0 Pro：240秒以上。1回のリクエストに通常約2分かかります。
* 5.0 Flashまたは5.0 Proのレイヤー分解：`1K` で300秒以上。

## 関連ドキュメント

* [Seedream 5.0 Flash・5.0 Proの提供開始](https://docs.laozhang.ai/en/announcements/seedream-5-0-flash-pro-2026-09.md)：価格、移行の注意点、バージョンの比較
* [画像APIの比較](https://docs.laozhang.ai/ja/api-capabilities/image-generation-guide.md)：Seedreamとほかの画像モデルの比較
* [Images API](https://docs.laozhang.ai/ja/api-reference/images.md)：共通のリクエストとレスポンスの形式
* [AIモデルのAPI料金一覧](https://docs.laozhang.ai/ja/models.md)：Seedreamの現在の価格とグループ
* [呼び出しログ](https://docs.laozhang.ai/en/faq/call-logs.md)：リクエストごとのモデルと課金額の確認

## 参考資料

* [BytePlus ModelArk 画像生成API](https://docs.byteplus.com/en/docs/ModelArk/1541523)：Seedreamの公式リクエストパラメーター、`size` の範囲、URLの有効期間
* [BytePlus 画像生成チュートリアル](https://docs.byteplus.com/en/docs/ModelArk/1824121)：モデルの比較、連続生成、入力画像の制限
* [Seedream 4.0ユーザーマニュアル](https://docs.byteplus.com/en/docs/ModelArk/seedream-4-0-user-manual)：BytePlusによるプロンプトの書き方と例
* [コンソールのモデルと料金](https://api.laozhang.ai/account/pricing)：自分のアカウントで使える価格


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.