Seedream - Image Generation

Authorization: Bearer gt_your_api_key_here

POST https://api.goodtake.ai/api/v1/bytedance/generate-image

{
  "prompt": "A beautiful sunset over mountains",
  "model": "seedream-4-5-251128",
  "number_of_images": 1,
  "size": "2K",
  "optimize_prompt_mode": "standard",
  "include_base64_encoding": false,
  "image_urls": []
}

{
  "url": "https://cdn.goodtake.ai/images/abc123.png",
  "base64": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..."
}

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..." alt="Generated image" />

{
  "prompt": "Transform this landscape into a cyberpunk scene with neon lights",
  "model": "seedream-4-5-251128",
  "image_urls": [
    "https://example.com/landscape.jpg"
  ],
  "number_of_images": 1
}

{
  "prompt": "Add dramatic lighting and enhance colors",
  "image_urls": [
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..."
  ]
}

{
  "status": "success",
  "data": {
    "images": [
      {
        "url": "https://cdn.goodtake.ai/images/abc123.png",
        "width": 1024,
        "height": 1024
      }
    ],
    "generation_time_ms": 3420,
    "model": "seedream-4-5-251128",
    "prompt": "A beautiful sunset over mountains"
  }
}

{
  "status": "success",
  "data": {
    "images": [
      {
        "url": "https://cdn.goodtake.ai/images/abc123.png",
        "base64": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...",
        "width": 1024,
        "height": 1024
      }
    ],
    "generation_time_ms": 3420,
    "model": "seedream-4-5-251128",
    "prompt": "A beautiful sunset over mountains"
  }
}

{
  "error": {
    "code": "invalid_parameters",
    "message": "Width must be between 128 and 2048 pixels"
  }
}

{
  "error": {
    "code": "unauthorized",
    "message": "Invalid or missing API key"
  }
}

{
  "error": {
    "code": "insufficient_credits",
    "message": "Insufficient credits to complete this request"
  }
}

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Rate limit exceeded. Please try again in 60 seconds.",
    "retry_after": 60
  }
}

curl -X POST https://api.goodtake.ai/api/v1/bytedance/generate-image \
  -H "Authorization: Bearer gt_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A beautiful sunset over mountains"
  }'

curl -X POST https://api.goodtake.ai/api/v1/bytedance/generate-image \
  -H "Authorization: Bearer $GOODTAKE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A cyberpunk cityscape with neon lights and flying cars",
    "model": "seedream-4-5-251128",
    "size": "2560x1440",
    "number_of_images": 2,
    "optimize_prompt_mode": "creative"
  }'

curl -X POST https://api.goodtake.ai/api/v1/bytedance/generate-image \
  -H "Authorization: Bearer $GOODTAKE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A serene forest path with morning mist",
    "model": "seedream-4-0-250828",
    "size": "1024x1024"
  }'

curl -X POST https://api.goodtake.ai/api/v1/bytedance/generate-image \
  -H "Authorization: Bearer $GOODTAKE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A futuristic robot in a laboratory",
    "model": "seedream-4-5-251128",
    "include_base64_encoding": true
  }'

curl -X POST https://api.goodtake.ai/api/v1/bytedance/generate-image \
  -H "Authorization: Bearer $GOODTAKE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Transform into a dramatic noir style with high contrast",
    "model": "seedream-4-5-251128",
    "image_urls": ["https://example.com/photo.jpg"]
  }'

import requests
import os
import base64

API_KEY = os.environ.get("GOODTAKE_API_KEY")
BASE_URL = "https://api.goodtake.ai"

def generate_image(prompt, model="seedream-4-5-251128", size="2K", 
                   include_base64=False):
    """Generate an image using GoodTake AI"""
    response = requests.post(
        f"{BASE_URL}/api/v1/bytedance/generate-image",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "prompt": prompt,
            "model": model,
            "size": size,
            "number_of_images": 1,
            "optimize_prompt_mode": "standard",
            "include_base64_encoding": include_base64
        }
    )
    
    response.raise_for_status()
    data = response.json()
    return data["data"]["images"][0]

def blend_image(prompt, image_url, model="seedream-4-5-251128"):
    """Blend/edit an existing image"""
    response = requests.post(
        f"{BASE_URL}/api/v1/bytedance/generate-image",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "prompt": prompt,
            "model": model,
            "image_urls": [image_url],
            "number_of_images": 1
        }
    )
    
    response.raise_for_status()
    data = response.json()
    return data["data"]["images"][0]

# Example 1: Basic generation
image = generate_image("A beautiful sunset over mountains")
print(f"Generated image URL: {image['url']}")

# Example 2: Using legacy model
image = generate_image(
    "A serene forest path",
    model="seedream-4-0-250828"
)
print(f"Generated with legacy model: {image['url']}")

# Example 3: With base64 encoding
image = generate_image(
    "A futuristic cityscape",
    include_base64=True
)
print(f"URL: {image['url']}")
print(f"Has base64: {'base64' in image}")

# Example 4: Image blending
edited = blend_image(
    "Add dramatic sunset lighting",
    "https://example.com/landscape.jpg"
)
print(f"Edited image: {edited['url']}")

const GOODTAKE_API_KEY = process.env.GOODTAKE_API_KEY;
const BASE_URL = "https://api.goodtake.ai";

async function generateImage(prompt, options = {}) {
  const payload = {
    prompt,
    model: options.model || "seedream-4-5-251128",
    size: options.size || "2K",
    number_of_images: options.numberOfImages || 1,
    optimize_prompt_mode: options.optimizeMode || "standard",
    include_base64_encoding: options.includeBase64 || false,
    image_urls: options.imageUrls || []
  };

  const response = await fetch(`${BASE_URL}/api/v1/bytedance/generate-image`, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${GOODTAKE_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify(payload)
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Error: ${error.error.message}`);
  }

  const data = await response.json();
  return data.data.images[0];
}

async function blendImage(prompt, imageUrl, model = "seedream-4-5-251128") {
  return generateImage(prompt, {
    model,
    imageUrls: [imageUrl]
  });
}

// Example 1: Basic generation
generateImage("A beautiful sunset over mountains")
  .then(image => console.log(`Generated: ${image.url}`))
  .catch(error => console.error(error));

// Example 2: Using latest model with widescreen size
generateImage("A cyberpunk street scene", {
  model: "seedream-4-5-251128",
  size: "2560x1440",
  optimizeMode: "creative"
})
  .then(image => console.log(`Generated: ${image.url}`))
  .catch(error => console.error(error));

// Example 3: With base64 encoding
generateImage("A futuristic robot", {
  includeBase64: true
})
  .then(image => {
    console.log(`URL: ${image.url}`);
    console.log(`Has base64: ${!!image.base64}`);
  })
  .catch(error => console.error(error));

// Example 4: Image blending
blendImage(
  "Add dramatic noir lighting",
  "https://example.com/photo.jpg"
)
  .then(image => console.log(`Edited: ${image.url}`))
  .catch(error => console.error(error));

package main

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

const BaseURL = "https://api.goodtake.ai"

// SeedreamRequest represents the image generation request
type SeedreamRequest struct {
    Prompt               string   `json:"prompt"`
    Model                string   `json:"model,omitempty"`
    NumberOfImages       int      `json:"number_of_images,omitempty"`
    Size                 string   `json:"size,omitempty"`
    OptimizePromptMode   string   `json:"optimize_prompt_mode,omitempty"`
    IncludeBase64Encoding bool    `json:"include_base64_encoding,omitempty"`
    ImageURLs            []string `json:"image_urls,omitempty"`
}

// Image represents a generated image
type Image struct {
    URL    string `json:"url"`
    Base64 string `json:"base64,omitempty"`
    Width  int    `json:"width"`
    Height int    `json:"height"`
}

// SeedreamResponse represents the API response
type SeedreamResponse struct {
    Status string `json:"status"`
    Data   struct {
        Images           []Image `json:"images"`
        GenerationTimeMs int     `json:"generation_time_ms"`
        Model            string  `json:"model"`
        Prompt           string  `json:"prompt"`
    } `json:"data"`
}

// GenerateImageOptions configures image generation
type GenerateImageOptions struct {
    Model                string
    Size                 string
    NumberOfImages       int
    OptimizePromptMode   string
    IncludeBase64        bool
    ImageURLs            []string
}

// DefaultOptions returns default generation options
func DefaultOptions() GenerateImageOptions {
    return GenerateImageOptions{
        Model:              "seedream-4-5-251128",
        Size:               "2K",
        NumberOfImages:     1,
        OptimizePromptMode: "standard",
        IncludeBase64:      false,
        ImageURLs:          []string{},
    }
}

// GenerateImage generates an image using the GoodTake AI API
func GenerateImage(ctx context.Context, prompt string, opts GenerateImageOptions) (*Image, error) {
    apiKey := os.Getenv("GOODTAKE_API_KEY")
    if apiKey == "" {
        return nil, fmt.Errorf("GOODTAKE_API_KEY environment variable not set")
    }

    reqBody := SeedreamRequest{
        Prompt:               prompt,
        Model:                opts.Model,
        NumberOfImages:       opts.NumberOfImages,
        Size:                 opts.Size,
        OptimizePromptMode:   opts.OptimizePromptMode,
        IncludeBase64Encoding: opts.IncludeBase64,
        ImageURLs:            opts.ImageURLs,
    }

    jsonData, err := json.Marshal(reqBody)
    if err != nil {
        return nil, fmt.Errorf("failed to marshal request: %w", err)
    }

    req, err := http.NewRequestWithContext(
        ctx,
        "POST",
        BaseURL+"/api/v1/bytedance/generate-image",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        return nil, fmt.Errorf("failed to create request: %w", err)
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

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

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("failed to read response: %w", err)
    }

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API error (status %d): %s", resp.StatusCode, string(body))
    }

    var result SeedreamResponse
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, fmt.Errorf("failed to parse response: %w", err)
    }

    if len(result.Data.Images) == 0 {
        return nil, fmt.Errorf("no images generated")
    }

    return &result.Data.Images[0], nil
}

// BlendImage edits an existing image based on a prompt
func BlendImage(ctx context.Context, prompt, imageURL string, model string) (*Image, error) {
    opts := DefaultOptions()
    opts.Model = model
    opts.ImageURLs = []string{imageURL}
    return GenerateImage(ctx, prompt, opts)
}

func main() {
    ctx := context.Background()

    // Example 1: Basic generation with latest model
    image, err := GenerateImage(ctx, "A beautiful sunset over mountains", DefaultOptions())
    if err != nil {
        panic(err)
    }
    fmt.Printf("Generated image: %s\n", image.URL)

    // Example 2: Using widescreen size
    opts := DefaultOptions()
    opts.Size = "2560x1440"
    image, err = GenerateImage(ctx, "A cyberpunk cityscape", opts)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Generated with widescreen: %s\n", image.URL)

    // Example 3: With base64 encoding
    opts = DefaultOptions()
    opts.IncludeBase64 = true
    image, err = GenerateImage(ctx, "A futuristic robot", opts)
    if err != nil {
        panic(err)
    }
    fmt.Printf("URL: %s\n", image.URL)
    fmt.Printf("Has base64: %t\n", image.Base64 != "")

    // Example 4: Image blending
    edited, err := BlendImage(
        ctx,
        "Add dramatic noir lighting",
        "https://example.com/photo.jpg",
        "seedream-4-5-251128",
    )
    if err != nil {
        panic(err)
    }
    fmt.Printf("Edited image: %s\n", edited.URL)
}

try:
    image_url = generate_image(prompt)
    print(f"Success: {image_url}")
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 429:
        print("Rate limited. Waiting before retry...")
        time.sleep(60)
    elif e.response.status_code == 403:
        print("Insufficient credits. Please add credits to your account.")
    else:
        print(f"Error: {e}")