Seedream v4.5 Text to Image

# Step 1: Submit image generation task
curl --request POST \
  --url https://api.apipod.ai/v1/images/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "seedream-v4.5",
    "prompt": "A vibrant close-up editorial portrait, model with intense gaze, wearing a sculptural hat, rich color blocking, sharp eye focus, shallow depth of field, Vogue magazine cover aesthetic",
    "aspect_ratio": "3:4",
    "quality": "2K"
  }'

# Response example:
# {"code": 0, "message": "success", "data": {"task_id": "task_abc123xyz"}}

# Step 2: Poll task status
curl --request GET \
  --url https://api.apipod.ai/v1/images/status/task_abc123xyz \
  --header 'Authorization: Bearer <token>'

import requests
import time

API_KEY = "<token>"
BASE_URL = "https://api.apipod.ai/v1"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

# Step 1: Submit image generation task
response = requests.post(
    f"{BASE_URL}/images/generations",
    headers=headers,
    json={
        "model": "seedream-v4.5",
        "prompt": "A vibrant close-up editorial portrait, model with intense gaze, wearing a sculptural hat, rich color blocking",
        "aspect_ratio": "3:4",
        "quality": "2K"
    }
)

task_id = response.json()["data"]["task_id"]
print(f"Task submitted: {task_id}")

# Step 2: Poll task status
while True:
    status_response = requests.get(
        f"{BASE_URL}/images/status/{task_id}",
        headers=headers
    )
    data = status_response.json()["data"]

    if data["status"] == "completed":
        print("Image generation complete!")
        print("Image URL:", data["result"])
        break
    elif data["status"] == "failed":
        print("Task failed")
        break
    else:
        print(f"Status: {data['status']}, waiting...")
        time.sleep(2)  # Poll every 2 seconds

const API_KEY = "<token>";
const BASE_URL = "https://api.apipod.ai/v1";

const headers = {
  "Authorization": `Bearer ${API_KEY}`,
  "Content-Type": "application/json"
};

async function generateImage() {
  // Step 1: Submit image generation task
  const submitResponse = await fetch(`${BASE_URL}/images/generations`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      model: "seedream-v4.5",
      prompt: "A vibrant close-up editorial portrait, model with intense gaze, wearing a sculptural hat, rich color blocking",
      aspect_ratio: "3:4",
      quality: "2K"
    })
  });

  const { data: { task_id } } = await submitResponse.json();
  console.log(`Task submitted: ${task_id}`);

  // Step 2: Poll task status
  while (true) {
    const statusResponse = await fetch(
      `${BASE_URL}/images/status/${task_id}`,
      { headers }
    );
    const { data } = await statusResponse.json();

    if (data.status === "completed") {
      console.log("Image generation complete!");
      console.log("Image URL:", data.result);
      break;
    } else if (data.status === "failed") {
      console.log("Task failed");
      break;
    } else {
      console.log(`Status: ${data.status}, waiting...`);
      await new Promise(resolve => setTimeout(resolve, 2000));
    }
  }
}

generateImage();

package main

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

const (
    apiKey  = "<token>"
    baseURL = "https://api.apipod.ai/v1"
)

type SubmitResponse struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
    Data    struct {
        TaskID string `json:"task_id"`
    } `json:"data"`
}

type StatusResponse struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
    Data    struct {
        TaskID      string   `json:"task_id"`
        Status      string   `json:"status"`
        CompletedAt int64    `json:"completed_at"`
        Result      []string `json:"result"`
    } `json:"data"`
}

func main() {
    // Step 1: Submit image generation task
    payload := map[string]interface{}{
        "model":        "seedream-v4.5",
        "prompt":       "A vibrant close-up editorial portrait, model with intense gaze, wearing a sculptural hat",
        "aspect_ratio": "3:4",
        "quality":      "2K",
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", baseURL+"/images/generations", bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    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)
    var submitResp SubmitResponse
    json.Unmarshal(body, &submitResp)

    taskID := submitResp.Data.TaskID
    fmt.Printf("Task submitted: %s\n", taskID)

    // Step 2: Poll task status
    for {
        req, _ := http.NewRequest("GET", baseURL+"/images/status/"+taskID, nil)
        req.Header.Set("Authorization", "Bearer "+apiKey)

        resp, _ := client.Do(req)
        body, _ := ioutil.ReadAll(resp.Body)
        resp.Body.Close()

        var statusResp StatusResponse
        json.Unmarshal(body, &statusResp)

        if statusResp.Data.Status == "completed" {
            fmt.Println("Image generation complete!")
            fmt.Println("Image URL:", statusResp.Data.Result)
            break
        } else if statusResp.Data.Status == "failed" {
            fmt.Println("Task failed")
            break
        } else {
            fmt.Printf("Status: %s, waiting...\n", statusResp.Data.Status)
            time.Sleep(2 * time.Second)
        }
    }
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class SeedreamExample {
    private static final String API_KEY = "<token>";
    private static final String BASE_URL = "https://api.apipod.ai/v1";

    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        // Step 1: Submit image generation task
        String payload = """
        {
          "model": "seedream-v4.5",
          "prompt": "A vibrant close-up editorial portrait, model with intense gaze, wearing a sculptural hat",
          "aspect_ratio": "3:4",
          "quality": "2K"
        }
        """;

        HttpRequest submitRequest = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/images/generations"))
            .header("Authorization", "Bearer " + API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> submitResponse = client.send(submitRequest,
            HttpResponse.BodyHandlers.ofString());

        JsonObject submitJson = JsonParser.parseString(submitResponse.body()).getAsJsonObject();
        String taskId = submitJson.getAsJsonObject("data").get("task_id").getAsString();
        System.out.println("Task submitted: " + taskId);

        // Step 2: Poll task status
        while (true) {
            HttpRequest statusRequest = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/images/status/" + taskId))
                .header("Authorization", "Bearer " + API_KEY)
                .GET()
                .build();

            HttpResponse<String> statusResponse = client.send(statusRequest,
                HttpResponse.BodyHandlers.ofString());

            JsonObject statusJson = JsonParser.parseString(statusResponse.body()).getAsJsonObject();
            String status = statusJson.getAsJsonObject("data").get("status").getAsString();

            if ("completed".equals(status)) {
                System.out.println("Image generation complete!");
                System.out.println("Image URL: " + statusJson.getAsJsonObject("data").get("result"));
                break;
            } else if ("failed".equals(status)) {
                System.out.println("Task failed");
                break;
            } else {
                System.out.println("Status: " + status + ", waiting...");
                Thread.sleep(2000);
            }
        }
    }
}