图像生成

最后更新：2026-11-14

POSThttps://www.sagelib.com/images/generations

图像生成API，接收用户的文本描述（Prompt），返回AI生成的全新图像，适用于创意设计、内容创作等场景。

接口鉴权方式请参考：API接入与鉴权

当前展示通用接口文档，各模型支持的参数存在差异。请点击下方模型标签查看专属文档。

支持模型：doubao-seedream-5-0-260128doubao-seedream-4-5-251128gpt-image-2.5-flaregpt-image-2.5-sunburstgemini-nano-banana-2.1gpt-image-2

请求参数

请求头

参数名称 描述
*Authorization string 鉴权令牌，格式为 Bearer ${AIGATEWAY_TOKEN}
*Content-Type string 可选值：application/json
application/json

Body 参数

参数名称 描述
model string 默认值：Per AI gateway configuration
模型 ID，固定值
*prompt string 生成图像的核心提示词，描述图像内容与风格
n integer 默认值：1
可选值：>0
生成图像的数量（部分模型可能限制为1）
response_format string 默认值：url
可选值：url、b64_json
图像返回格式（部分模型可能限制格式）
size string 默认值：1024x1024
可选值：Varies by model
图像宽高像素（部分模型可能限制分辨率）
style string 图像风格（仅OpenAI系支持）
quality string 默认值：auto
图像质量（可能影响生成时间和输出效果，仅OpenAI系支持）
user string 用户标识，用于指定生成请求用户（仅OpenAI系支持）

请求示例

curl -v 'https://www.sagelib.com/images/generations' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Sunset by the sea",
    "size": "1440x900"
  }'

import json
import requests

base_url = "https://www.sagelib.com"
api_key = "***"
url = f"https://www.sagelib.com/images/generations"
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
data = {
    "prompt": "Sunset by the sea",
    "size": "1440x900"
}

response = requests.post(url, headers=headers, json=data)
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/images/generations";

        String jsonRequestBody = """
            {
                "prompt": "Sunset by the sea",
                "size": "1440x900"
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println("Status Code: " + response.statusCode());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/images/generations"

    jsonRequestBody := `
            {
                "prompt": "Sunset by the sea",
                "size": "1440x900"
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

响应参数

Body 参数

参数名称 描述
created integer 图像创建的时间戳（Unix时间格式）
data array 生成的图像数组，数组长度与请求参数n一致（部分模型固定为1）
    url string 图像的URL地址，仅当response_format=url时返回（必填）
    b64_json string 图像内容的Base64编码，仅当response_format=b64_json时返回（必填）

响应示例

{
  "created": 1754372091,
  "data": [
    {
      "url": "https://example.com/generated-image.png"
    }
  ]
}

{
  "created": 1754372401,
  "data": [
    {
      "b64_json": "/9j/4AAQSkZJRgABAQAAAQABAAD/4QBjRXhpZgAATU0AKgAA..."
    }
  ]
}

状态码

HTTP状态码 描述
200 请求成功，返回生成的图像数据
401 访问被拒绝，拒绝原因见响应主体。可能原因：缺少Authorization请求头、token无效或过期等
403 访问被拒绝，拒绝原因见响应主体。可能原因：请求主体JSON格式错误、缺少必填参数（如prompt）等
500 服务器内部错误，错误原因见响应主体
POSThttps://www.sagelib.com/openai/images/generations

OpenAI 直连模式图像生成API，接收文本描述（Prompt）生成图像，URL 前缀 /openai，适用于已按 OpenAI 官方 SDK 接入的场景。

接口鉴权方式请参考：API接入与鉴权

当前展示通用接口文档，各模型支持的参数存在差异。请点击下方模型标签查看专属文档。

支持模型：gpt-image-2.5-flaregpt-image-2.5-sunburstgpt-image-2doubao-seedream-4-5-251128

请求参数

请求头

参数名称 描述
*Authorization string 鉴权令牌，格式为 Bearer ${AIGATEWAY_TOKEN}
*Content-Type string 可选值：application/json
application/json

Body 参数

参数名称 描述
model string 可选值：gpt-image-2.5-flare / gpt-image-2.5-sunburst / gpt-image-2 / seedream-4-5-251128
指定使用的模型名
prompt string 图像生成的文本描述提示词
n integer 默认值：1
可选值：1-10
一次请求生成的图像数量
size string 默认值：1024x1024
可选值：auto / 1024x1024 / 1536x1024 / 1024x1536 (+ custom WxH; gpt-image-2 width/height must be divisible by 16; seedream-4-5: 2K / 4K)
输出图像分辨率
quality string 默认值：auto
可选值：auto / low / medium / high / xhigh / max (gpt-image-2: auto / high / medium / low)
图像质量档位
background string 默认值：auto
可选值：transparent / opaque / auto (gpt-image-2: auto / opaque)
背景处理方式
output_format string 默认值：png
可选值：png / jpeg / webp
输出图像编码格式
output_compression integer 默认值：100
可选值：0-100 (jpeg/webp only)
有损压缩率百分比，仅 jpeg/webp 生效
partial_images integer 默认值：0
可选值：0-3
流式模式下返回的中间预览图数量
stream boolean 默认值：false
可选值：true、false
是否流式返回
user string 终端用户标识符
moderation string 默认值：auto
可选值：low / auto (gpt-image-2: auto / low)
内容审核级别

请求示例

curl -v 'https://www.sagelib.com/openai/images/generations' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.5-flare",
    "prompt": "An orange tabby crouches on a windowsill; outside is a city skyline in sunset glow, watercolor style, warm tones, soft light, rich color layers",
    "size": "1024x1024"
  }'

import json
import requests

base_url = "https://www.sagelib.com"
api_key = "***"
url = f"https://www.sagelib.com/openai/images/generations"
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
data = {
    "model": "gpt-image-2.5-flare",
    "prompt": "An orange tabby crouches on a windowsill; outside is a city skyline in sunset glow, watercolor style, warm tones, soft light, rich color layers",
    "size": "1024x1024"
}

response = requests.post(url, headers=headers, json=data)
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/openai/images/generations";

        String jsonRequestBody = """
            {
                "model": "gpt-image-2.5-flare",
                "prompt": "An orange tabby crouches on a windowsill; outside is a city skyline in sunset glow, watercolor style, warm tones, soft light, rich color layers",
                "size": "1024x1024"
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println("Status Code: " + response.statusCode());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/openai/images/generations"

    jsonRequestBody := `
            {
                "model": "gpt-image-2.5-flare",
                "prompt": "An orange tabby crouches on a windowsill; outside is a city skyline in sunset glow, watercolor style, warm tones, soft light, rich color layers",
                "size": "1024x1024"
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

curl -v 'https://www.sagelib.com/openai/images/generations' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.5-flare",
    "prompt": "A snowy mountain under the aurora, photo-realistic, long exposure",
    "size": "1024x1024",
    "stream": true
  }'

import json
import requests

base_url = "https://www.sagelib.com"
api_key = "***"
url = f"https://www.sagelib.com/openai/images/generations"
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
data = {
    "model": "gpt-image-2.5-flare",
    "prompt": "A snowy mountain under the aurora, photo-realistic, long exposure",
    "size": "1024x1024",
    "stream": True
}

response = requests.post(url, headers=headers, json=data)
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/openai/images/generations";

        String jsonRequestBody = """
            {
                "model": "gpt-image-2.5-flare",
                "prompt": "A snowy mountain under the aurora, photo-realistic, long exposure",
                "size": "1024x1024",
                "stream": true
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println("Status Code: " + response.statusCode());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/openai/images/generations"

    jsonRequestBody := `
            {
                "model": "gpt-image-2.5-flare",
                "prompt": "A snowy mountain under the aurora, photo-realistic, long exposure",
                "size": "1024x1024",
                "stream": true
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

响应参数

Body 参数

参数名称 描述
background string 实际背景处理方式
created integer 生成时间戳（Unix 秒）
data array 图像数组，长度 = n
    b64_json string Base64 编码的图像数据
    generation_id string 本次生成的标识 ID
output_format string 实际输出格式
quality string 实际质量档位
size string 实际输出尺寸
usage object Token 使用统计
    input_tokens integer 输入 token 数（input_tokens_details 含 image_tokens/text_tokens 细分）
    output_tokens integer 输出 token 数（output_tokens_details 含 image_tokens 细分）
    total_tokens integer 总 token 数

状态码

HTTP状态码 描述
200 请求成功
401 访问被拒绝，拒绝原因见响应主体。可能的原因有：缺少Authorization请求头，token错误等。
403 访问被拒绝，拒绝原因见响应主体。可能的原因有：请求主体格式错误、请求主体缺少用户问题等。
500 服务器内部错误，原因见响应主体
POSThttps://www.sagelib.com/gemini/v1beta/models/{model}:generateContent

Gemini 直连模式的图像生成端点，以 Gemini 原生 generateContent 接口格式访问图像模型。图像模型同时支持文本对话、图像输入理解与图像生成（generationConfig.responseModalities 指定 IMAGE）等多模态能力。

接口鉴权方式请参考：API接入与鉴权

当前展示通用接口文档，各模型支持的参数存在差异。请点击下方模型标签查看专属文档。

支持模型：gemini-nano-banana-2.1

请求参数

请求头

参数名称 描述
*Content-Type string 可选值：application/json
application/json
*x-goog-api-key string 鉴权令牌，格式为 ${AIGATEWAY_TOKEN}

Body 参数

参数名称 描述
*contents array 对话内容数组，每项含 role 和 parts
contents[].role string 默认值：user
可选值：user / model
消息发送者角色: user 或 model
contents[].parts array 消息的内容部分数组
contents[].parts[].text string 文本内容（与 inlineData 至少提供其一）
contents[].parts[].inlineData object 内联二进制数据，含 mimeType（如 image/png）和 data（base64 编码）
systemInstruction object 系统指令，格式同 contents（含 role 和 parts）
generationConfig object 生成行为控制参数
generationConfig.temperature number 可选值：0 ~ 2
采样温度，控制输出随机性
generationConfig.topP number 可选值：0 ~ 1
核采样概率阈值
generationConfig.topK integer Top-K 采样，限制候选 token 范围
generationConfig.maxOutputTokens integer 最大输出 token 数量
generationConfig.responseModalities array 可选值：TEXT / IMAGE
输出模态: TEXT（文本）、IMAGE（图像）等
generationConfig.imageConfig object 图像生成配置（如 aspectRatio、imageSize）
generationConfig.stopSequences array 停止序列列表
safetySettings array 安全过滤设置，每项含 category 和 threshold

请求示例

curl -v 'https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent' \
  -H "x-goog-api-key: ***" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "Hello, introduce yourself briefly."
          }
        ]
      }
    ]
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your API key

url = f"https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent"

headers = {
    "x-goog-api-key": api_key,
    "Content-Type": "application/json",
}

data = {
    "contents": [
        {
            "role": "user",
            "parts": [
                {
                    "text": "Hello, introduce yourself briefly."
                }
            ]
        }
    ]
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent";

        String jsonRequestBody = """
            {
              "contents": [
                {
                  "role": "user",
                  "parts": [
                    {
                      "text": "Hello, introduce yourself briefly."
                    }
                  ]
                }
              ]
            }
            """;

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("x-goog-api-key", apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Status Code: " + response.statusCode());
        System.out.println(response.body());
    }
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent"

    jsonRequestBody := `
            {
              "contents": [
                {
                  "role": "user",
                  "parts": [
                    {
                      "text": "Hello, introduce yourself briefly."
                    }
                  ]
                }
              ]
            }
            `

    req, _ := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    req.Header.Set("x-goog-api-key", apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Status Code:", resp.StatusCode)
    fmt.Println(string(body))
}

curl -v 'https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent' \
  -H "x-goog-api-key: ***" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "Explain quantum computing in one paragraph."
          }
        ]
      }
    ],
    "generationConfig": {
      "temperature": 0.7,
      "maxOutputTokens": 2048,
      "topP": 0.95
    }
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your API key

url = f"https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent"

headers = {
    "x-goog-api-key": api_key,
    "Content-Type": "application/json",
}

data = {
    "contents": [
        {
            "role": "user",
            "parts": [
                {
                    "text": "Explain quantum computing in one paragraph."
                }
            ]
        }
    ],
    "generationConfig": {
        "temperature": 0.7,
        "maxOutputTokens": 2048,
        "topP": 0.95
    }
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent";

        String jsonRequestBody = """
            {
              "contents": [
                {
                  "role": "user",
                  "parts": [
                    {
                      "text": "Explain quantum computing in one paragraph."
                    }
                  ]
                }
              ],
              "generationConfig": {
                "temperature": 0.7,
                "maxOutputTokens": 2048,
                "topP": 0.95
              }
            }
            """;

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("x-goog-api-key", apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Status Code: " + response.statusCode());
        System.out.println(response.body());
    }
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent"

    jsonRequestBody := `
            {
              "contents": [
                {
                  "role": "user",
                  "parts": [
                    {
                      "text": "Explain quantum computing in one paragraph."
                    }
                  ]
                }
              ],
              "generationConfig": {
                "temperature": 0.7,
                "maxOutputTokens": 2048,
                "topP": 0.95
              }
            }
            `

    req, _ := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    req.Header.Set("x-goog-api-key", apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Status Code:", resp.StatusCode)
    fmt.Println(string(body))
}

curl -v 'https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent' \
  -H "x-goog-api-key: ***" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "What is in this image? Describe it in detail."
          },
          {
            "inlineData": {
              "mimeType": "image/png",
              "data": "(base64_encoded_image_data)"
            }
          }
        ]
      }
    ]
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your API key

url = f"https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent"

headers = {
    "x-goog-api-key": api_key,
    "Content-Type": "application/json",
}

data = {
    "contents": [
        {
            "role": "user",
            "parts": [
                {
                    "text": "What is in this image? Describe it in detail."
                },
                {
                    "inlineData": {
                        "mimeType": "image/png",
                        "data": "(base64_encoded_image_data)"
                    }
                }
            ]
        }
    ]
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent";

        String jsonRequestBody = """
            {
              "contents": [
                {
                  "role": "user",
                  "parts": [
                    {
                      "text": "What is in this image? Describe it in detail."
                    },
                    {
                      "inlineData": {
                        "mimeType": "image/png",
                        "data": "(base64_encoded_image_data)"
                      }
                    }
                  ]
                }
              ]
            }
            """;

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("x-goog-api-key", apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Status Code: " + response.statusCode());
        System.out.println(response.body());
    }
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent"

    jsonRequestBody := `
            {
              "contents": [
                {
                  "role": "user",
                  "parts": [
                    {
                      "text": "What is in this image? Describe it in detail."
                    },
                    {
                      "inlineData": {
                        "mimeType": "image/png",
                        "data": "(base64_encoded_image_data)"
                      }
                    }
                  ]
                }
              ]
            }
            `

    req, _ := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    req.Header.Set("x-goog-api-key", apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Status Code:", resp.StatusCode)
    fmt.Println(string(body))
}

curl -v 'https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent' \
  -H "x-goog-api-key: ***" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "Generate an image of a golden retriever playing on a beach at sunset"
          }
        ]
      }
    ],
    "generationConfig": {
      "responseModalities": [
        "TEXT",
        "IMAGE"
      ]
    }
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your API key

url = f"https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent"

headers = {
    "x-goog-api-key": api_key,
    "Content-Type": "application/json",
}

data = {
    "contents": [
        {
            "role": "user",
            "parts": [
                {
                    "text": "Generate an image of a golden retriever playing on a beach at sunset"
                }
            ]
        }
    ],
    "generationConfig": {
        "responseModalities": [
            "TEXT",
            "IMAGE"
        ]
    }
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent";

        String jsonRequestBody = """
            {
              "contents": [
                {
                  "role": "user",
                  "parts": [
                    {
                      "text": "Generate an image of a golden retriever playing on a beach at sunset"
                    }
                  ]
                }
              ],
              "generationConfig": {
                "responseModalities": [
                  "TEXT",
                  "IMAGE"
                ]
              }
            }
            """;

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("x-goog-api-key", apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Status Code: " + response.statusCode());
        System.out.println(response.body());
    }
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/gemini/v1beta/models/{model}:generateContent"

    jsonRequestBody := `
            {
              "contents": [
                {
                  "role": "user",
                  "parts": [
                    {
                      "text": "Generate an image of a golden retriever playing on a beach at sunset"
                    }
                  ]
                }
              ],
              "generationConfig": {
                "responseModalities": [
                  "TEXT",
                  "IMAGE"
                ]
              }
            }
            `

    req, _ := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    req.Header.Set("x-goog-api-key", apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Status Code:", resp.StatusCode)
    fmt.Println(string(body))
}

响应参数

Body 参数

参数名称 描述
candidates array 候选回复数组
    candidates[].content.role string 可选值：model
固定为 model
    candidates[].content.parts[].text string 生成的文本内容
    candidates[].content.parts[].inlineData object 内联图像数据（含 mimeType 和 data）
    candidates[].finishReason string 结束原因，如 STOP / MAX_TOKENS / SAFETY
    candidates[].safetyRatings array 安全评级数组
usageMetadata.promptTokenCount integer 输入 token 数
usageMetadata.candidatesTokenCount integer 输出 token 数
usageMetadata.totalTokenCount integer 总 token 数
modelVersion string 模型版本号

响应示例

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": "Here is the generated image of a golden retriever on a beach at sunset:"
          },
          {
            "inlineData": {
              "mimeType": "image/png",
              "data": "(base64_encoded_image_data)"
            }
          }
        ]
      },
      "finishReason": "STOP",
      "index": 0
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 12,
    "candidatesTokenCount": 350,
    "totalTokenCount": 362
  },
  "modelVersion": "gemini-3-pro-image"
}

状态码

HTTP状态码 描述
200 请求成功
401 访问被拒绝，拒绝原因见响应主体。可能的原因有：缺少Authorization请求头，token错误等。
403 访问被拒绝，拒绝原因见响应主体。可能的原因有：请求主体格式错误、请求主体缺少用户问题等。
500 服务器内部错误，原因见响应主体