Seedream 5.0 Lite API: Najszybszy punkt końcowy generowania obrazów

REST API, autoryzacja Bearer, asynchroniczne generowanie, webhoki, natywne grupowanie do 50 obrazów na żądanie. Wszystko, co dostępne w internetowym interfejsie Arteza, jest również dostępne w API. Oto pełna dokumentacja z pracującymi przykładami w Pythonie i JavaScript, które można skopiować do produkcji dzisiaj.

Przegląd API

API Seedream 5.0 Lite zapewnia programowy dostęp do potoku generowania obrazów na platformie Arteza. Wszystko, co jest w interfejsie internetowym - konwersja tekstu na obraz, głębokie myślenie, transfer stylów, renderowanie tekstu - jest w REST API.

API stosuje się do konwencji REST z treściami żądań i odpowiedzi w formacie JSON. Generowanie jest asynchroniczne: prześlij żądanie, otrzymaj ID zadania, a następnie albo sonduj, albo otrzymaj webhook po zakończeniu.

Pełny przegląd funkcji w naszym pełny przewodnik.

Podstawowy adres URL

https://api.arteza.ai/v1

Kluczowe cechy

Uwierzytelnianie

Uwierzytelnianie tokenu Bearer. Wygeneruj swój klucz API z pulpitu nawigacyjnego Arteza w sekcji Ustawienia > Klucze API.

Uzyskiwanie klucza API

1. Zarejestruj się lub zaloguj się do swojego konta Arteza
2. Przejdź do Ustawienia > Klucze API
3. Kliknij Wygeneruj nowy klucz
4. Skopiuj i bezpiecznie przechowuj swój klucz (wyświetlany tylko raz)

Nagłówek uwierzytelniania

Authorization: Bearer YOUR_API_KEY

Testowanie uwierzytelniania

curl -H "Authorization: Bearer YOUR_API_KEY" \
     https://api.arteza.ai/v1/account/credits

Odpowiedź:

{
  "credits_remaining": 1050,
  "tier": "starter"
}

Punkt końcowy pojedynczego obrazu

POST /v1/images/generate

Minimalne żądanie

{
  "model": "seedream-5.0-lite",
  "prompt": "Spokojny górski krajobraz o wschodzącym słońcu"
}

Pełne żądanie

{
  "model": "seedream-5.0-lite",
  "prompt": "Profesjonalna miniatura YouTube z tekstem 'TOP 10 PORAD' w pogrubionej czerwonej czcionce, podekscytowana osoba po lewej, jasne niebieskie tło",
  "aspect_ratio": "16:9",
  "deep_thinking": true,
  "style": "photorealistic",
  "webhook_url": "https://your-app.com/webhook/image-complete",
  "metadata": {
    "project": "youtube-thumbnails",
    "batch_id": "thumb-2026-04"
  }
}

Odpowiedź

{
  "task_id": "img_abc123def456",
  "status": "processing",
  "model": "seedream-5.0-lite",
  "credits_charged": 7,
  "credits_remaining": 1043,
  "estimated_time_seconds": 10
}

Parametry żądania

Proporcje

Ustawienia stylów

Format odpowiedzi

Sondowanie wyników

GET /v1/images/{task_id}

W trakcie przetwarzania:

{
  "task_id": "img_abc123def456",
  "status": "processing",
  "progress": 0.65,
  "estimated_time_remaining": 5
}

Ukończone:

{
  "task_id": "img_abc123def456",
  "status": "completed",
  "image_url": "https://cdn.arteza.ai/generated/img_abc123def456.png",
  "image_url_webp": "https://cdn.arteza.ai/generated/img_abc123def456.webp",
  "width": 1024,
  "height": 1024,
  "model": "seedream-5.0-lite",
  "deep_thinking_used": true,
  "credits_charged": 7,
  "metadata": {
    "project": "youtube-thumbnails",
    "batch_id": "thumb-2026-04"
  },
  "created_at": "2026-04-10T14:30:00Z"
}

Wygaśnięcie adresu URL obrazu

Wygenerowane adresy URL obrazów są ważne przez 24 godziny. Pobierz i przechowuj obrazy w własnym magazynie w tym oknie.

Chcesz taki czysty tekst? Spróbuj Seedream 5.0 Lite za darmo →

Przykład Python

import requests
import time

API_KEY = "your_api_key_here"
BASE_URL = "https://api.arteza.ai/v1"

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

# Submit generation request
response = requests.post(
    f"{BASE_URL}/images/generate",
    headers=headers,
    json={
        "model": "seedream-5.0-lite",
        "prompt": "Przyszłościowy horyzont miasta przy zachodzie słońca z latającymi samochodami",
        "aspect_ratio": "16:9",
        "deep_thinking": True
    }
)

task = response.json()
task_id = task["task_id"]
print(f"Zadanie przesłane: {task_id}")
print(f"Pobrane kredyty: {task['credits_charged']}")
print(f"Pozostałe kredyty: {task['credits_remaining']}")

# Poll for completion
while True:
    result = requests.get(
        f"{BASE_URL}/images/{task_id}",
        headers=headers
    ).json()

    if result["status"] == "completed":
        print(f"Obraz gotowy: {result['image_url']}")
        break
    elif result["status"] == "failed":
        print(f"Generowanie nie powiodło się: {result.get('error', 'Nieznany błąd')}")
        break

    time.sleep(2)

Przykład JavaScript

const API_KEY = 'your_api_key_here';
const BASE_URL = 'https://api.arteza.ai/v1';

async function generateImage(prompt, options = {}) {
  const response = await fetch(`${BASE_URL}/images/generate`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: 'seedream-5.0-lite',
      prompt,
      aspect_ratio: options.aspectRatio || '1:1',
      deep_thinking: options.deepThinking || false,
      ...options
    })
  });

  const task = await response.json();
  console.log(`Zadanie przesłane: ${task.task_id}`);

  while (true) {
    const result = await fetch(
      `${BASE_URL}/images/${task.task_id}`,
      { headers: { 'Authorization': `Bearer ${API_KEY}` } }
    ).then(r => r.json());

    if (result.status === 'completed') {
      return result;
    }
    if (result.status === 'failed') {
      throw new Error(result.error || 'Generowanie nie powiodło się');
    }

    await new Promise(resolve => setTimeout(resolve, 2000));
  }
}

// Usage
const result = await generateImage(
  'Przytulna kawiarnia z ciepłym oświetleniem',
  { aspectRatio: '16:9', deepThinking: true }
);
console.log(`Adres URL obrazu: ${result.image_url}`);

Pobieranie wygenerowanych obrazów

import requests

def download_image(image_url, filename):
    response = requests.get(image_url)
    with open(filename, 'wb') as f:
        f.write(response.content)
    print(f"Zapisano: {filename}")

download_image(result['image_url'], 'output/my_image.png')

Punkt końcowy grupowania

Dla wielu obrazów w jednym żądaniu:

POST /v1/images/batch

Żądanie grupowania

{
  "generations": [
    {
      "prompt": "Minimalny projekt logo, niebieski okrąg z piorunem",
      "model": "seedream-5.0-lite",
      "aspect_ratio": "1:1",
      "deep_thinking": true
    },
    {
      "prompt": "Profesjonalne tło zdjęcia profilowego, miękki gradient",
      "model": "seedream-5.0-lite",
      "aspect_ratio": "1:1",
      "deep_thinking": false
    },
    {
      "prompt": "Miniatura YouTube z tekstem 'OBOWIĄ ZOBACZYĆ' na czerwono",
      "model": "seedream-5.0-lite",
      "aspect_ratio": "16:9",
      "deep_thinking": true
    }
  ],
  "webhook_url": "https://your-app.com/webhook/batch-complete"
}

Odpowiedź grupowania

{
  "batch_id": "batch_xyz789",
  "status": "processing",
  "total_generations": 3,
  "total_credits_charged": 21,
  "credits_remaining": 1029
}

Sondowanie stanu grupowania

GET /v1/images/batch/{batch_id}

{
  "batch_id": "batch_xyz789",
  "status": "completed",
  "results": [
    {
      "index": 0,
      "status": "completed",
      "task_id": "img_001",
      "image_url": "https://cdn.arteza.ai/generated/img_001.png"
    },
    {
      "index": 1,
      "status": "completed",
      "task_id": "img_002",
      "image_url": "https://cdn.arteza.ai/generated/img_002.png"
    },
    {
      "index": 2,
      "status": "completed",
      "task_id": "img_003",
      "image_url": "https://cdn.arteza.ai/generated/img_003.png"
    }
  ]
}

Limity grupowania

W przypadku przepływów pracy grupowania zobacz nasz przewodnik generowania zbiorczego.

Integracja webhooków

Webhoki eliminują sondowanie. Gdy generowanie się ukończy, API wysyła POST na Twój adres URL.

Ładunek webhooku

{
  "event": "image.completed",
  "task_id": "img_abc123def456",
  "batch_id": "batch_xyz789",
  "status": "completed",
  "image_url": "https://cdn.arteza.ai/generated/img_abc123def456.png",
  "model": "seedream-5.0-lite",
  "credits_charged": 7,
  "metadata": {
    "project": "youtube-thumbnails"
  },
  "created_at": "2026-04-10T14:30:00Z"
}

Przykład obsługi (Python/Flask)

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/webhook/image-complete', methods=['POST'])
def handle_image_webhook():
    data = request.json

    if data['event'] == 'image.completed':
        task_id = data['task_id']
        image_url = data['image_url']
        metadata = data.get('metadata', {})

        # Download image
        img_response = requests.get(image_url)
        filename = f"images/{metadata.get('project', 'default')}/{task_id}.png"
        with open(filename, 'wb') as f:
            f.write(img_response.content)

        # Update your database
        update_generation_record(task_id, filename)

        print(f"Obraz zapisany: {filename}")

    elif data['event'] == 'image.failed':
        print(f"Generowanie nie powiodło się: {data.get('error')}")

    return jsonify({'status': 'ok'}), 200

Bezpieczeństwo webhooku

Zweryfikuj autentyczność webhooku poprzez nagłówek X-Seedance-Signature:

import hmac
import hashlib

def verify_webhook(payload, signature, secret):
    expected = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

Tryb głębokiego myślenia

Kontrolowany przez parametr boolean deep_thinking. Gdy włączony, model przeprowadza dodatkowe rozumowanie przed generowaniem.

Kiedy włączyć

Wpływ na wydajność

Głębokie myślenie dodaje około 3-5 sekund, ale kosztuje zero dodatkowych kredytów.

Obsługa błędów

Format odpowiedzi błędu

{
  "error": {
    "code": "insufficient_credits",
    "message": "Za mało kredytów do ukończenia tego generowania. Wymagane: 7, Dostępne: 3",
    "status": 402
  }
}

Kody błędów

Strategia ponawiania

import time

def generate_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(
                f"{BASE_URL}/images/generate",
                headers=headers,
                json={
                    "model": "seedream-5.0-lite",
                    "prompt": prompt
                }
            )

            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 5))
                time.sleep(retry_after)
                continue

            response.raise_for_status()
            return response.json()

        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)  # Exponential backoff

Limity szybkości i najlepsze praktyki

Limity szybkości wg poziomu

Najlepsze praktyki

1. Używaj webhooków zamiast sondowania - bardziej efektywne
2. Grupuj, gdy to możliwe - jedno żądanie grupowania to więcej niż 50 pojedynczych żądań
3. Eksponencjalne wycofanie - obsługuj limity szybkości z gracją
4. Buforuj wyniki - przechowuj adresy URL obrazów i metadane w swojej bazie danych
5. Pobieraj szybko - adresy URL obrazów wygasają po 24 godzinach
6. Monitoruj saldo kredytów - sprawdzaj credits_remaining, aby uniknąć przerw
7. Używaj metadanych - otaguj generowania identyfikatorami projektów do śledzenia
8. Obsługuj błędy z gracją - nie każde generowanie powiedzie się

Instalacja SDK

Python:

pip install seedance

from seedance import SeedanceClient

client = SeedanceClient(api_key="your_key")
result = client.images.generate(
    model="seedream-5.0-lite",
    prompt="Piękny zachód słońca",
    deep_thinking=True
)

JavaScript:

npm install @seedance/sdk

import { SeedanceClient } from '@seedance/sdk';

const client = new SeedanceClient({ apiKey: 'your_key' });
const result = await client.images.generate({
    model: 'seedream-5.0-lite',
    prompt: 'Piękny zachód słońca',
    deepThinking: true
});

Typowe wzorce integracji

Integracja CMS

Automatycznie generuj obrazy wyróżnione podczas tworzenia wpisu:

@app.route('/cms/webhook/new-post', methods=['POST'])
def handle_new_post():
    post = request.json

    result = generate_image(
        prompt=f"Obraz nagłówka bloga dotyczący artykułu {post['title']}, "
               f"profesjonalny styl redakcyjny, 16:9",
        aspect_ratio="16:9",
        deep_thinking=True,
        metadata={"post_id": post["id"]}
    )

    update_post_featured_image(post["id"], result["image_url"])

Obrazy produktów e-commerce

def generate_product_images(product):
    prompts = [
        f"Zdjęcie produktu {product.name}, białe tło, oświetlenie studyjne, 1:1",
        f"Zdjęcie stylu życia {product.name} w użyciu, naturalne tło, 16:9",
        f"Zbliżenie szczegółów produktu {product.name}, makrofotografia, 1:1"
    ]

    batch = client.images.batch_generate(
        generations=[
            {"model": "seedream-5.0-lite", "prompt": p}
            for p in prompts
        ]
    )

    return batch

Automatyzacja mediów społecznościowych

def generate_weekly_social_content(brand, topics):
    generations = []
    for topic in topics:
        generations.append({
            "model": "seedream-5.0-lite",
            "prompt": f"{brand.style_prefix} {topic}, post mediów społecznościowych, 1:1",
            "aspect_ratio": "1:1",
            "deep_thinking": True,
            "metadata": {"topic": topic, "platform": "instagram"}
        })

    return client.images.batch_generate(generations=generations)

---

API Seedream 5.0 Lite to najszybsza droga od monitów tekstowych do wygenerowanych obrazów z pełną obsługą głębokiego myślenia, generowania grupowego i integracji webhooków.

Uzyskaj swój klucz API → - 50 darmowych kredytów, generuj swój klucz z Ustawienia > Klucze API, zacznij budować w minutach.