Seedream v4.5 API: Integrera AI-bilder i din app

Att integrera AI-bildgenerering i din app brukade betyda att välja mellan tre dåliga alternativ: köra Stable Diffusion själv (dyr infrastruktur), betala OpenAI per-token-priser (oförutsägbara kostnader), eller förbinda dig till ett prenumerations-API (slösaktig kapacitet). Seedream v4.5 API är byggd annorlunda - betala per bild för $0.08, standard REST, och svarstider mätta i sekunder. Den här guiden tar dig från noll till första generering på under 10 minuter.

Vad API:t är bra för

Seedream v4.5 API passar för applikationer som behöver AI-bildgenerering på begäran med förutsägbara per-bild-kostnader. Vanliga användningsfall:

SaaS-produkter som låter användare generera bilder som en del av sitt arbetsflöde - designverktyg, marknadsföringsplattformar, innehållsskapande-appar.

E-handelsplattformar som genererar produktlivestylebild eller kategorihuvuden programmatiskt.

Marknadsföringsautomation som producerar kampanjvisningar baserade på strukturerad inmatning.

Innehållshanteringssystem som erbjuder AI-bildgenerering som en inbyggd funktion.

Utvecklarprojekt och automatiseringsskript för alla arbetsflöden som behöver bildgenerering i stor skala.

Mobilappar som anropar API:t från en backend-tjänst för att hålla bildgenereringen utanför enheten.

Om ditt användningsfall matchar något av dessa kommer den här guiden att få dig integrerad snabbt.

Autentisering och komma igång

Steg 1: Få en API-nyckel

Registrera dig för ett Arteza-konto om du inte redan har ett. Navigera till dina kontoinställningar och generera en API-nyckel. Behandla den här nyckeln som ett lösenord - förbind den inte till offentliga arkiv.

Steg 2: Lägg till credits på ditt konto

API-användning drar från samma creditsaldo som webbanvändning. Dina 50 gratis registreringscredits fungerar på API-anrop. För produktionsanvändning, prenumerera från prissida från $10.

Steg 3: Gör din första förfrågan

API-slutpunkten för Seedream v4.5 är:

POST https://api.arteza.ai/v1/images/generate

Minsta begärandetekst:

{
  "model": "seedream-v4-5",
  "prompt": "En mysig bokhandel vid skymning, varm fönsterljus",
  "width": 2048,
  "height": 2048,
  "num_images": 1
}

Inkludera din API-nyckel i Authorization-huvudet:

Authorization: Bearer YOUR_API_KEY

Fullständig parameterreferens

Stödda upplösningar

Seedream v4.5 stöder flera upplösningsalternativ upp till 4 megapixlar:

Kodexempel

Node.js (Fetch)

const generateImage = async (prompt) => {
  const response = await fetch(
    'https://api.arteza.ai/v1/images/generate',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.SEEDANCE_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: 'seedream-v4-5',
        prompt: prompt,
        width: 2048,
        height: 2048,
        num_images: 1,
      }),
    }
  );

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

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

// Usage
const imageUrl = await generateImage(
  'A cozy bookstore at dusk, warm window light, editorial photography'
);
console.log(imageUrl);

Python (Requests)

import os
import requests

def generate_image(prompt, width=2048, height=2048, num_images=1):
    response = requests.post(
        'https://api.arteza.ai/v1/images/generate',
        headers={
            'Authorization': f'Bearer {os.environ["SEEDANCE_API_KEY"]}',
            'Content-Type': 'application/json',
        },
        json={
            'model': 'seedream-v4-5',
            'prompt': prompt,
            'width': width,
            'height': height,
            'num_images': num_images,
        },
    )
    response.raise_for_status()
    data = response.json()
    return [img['url'] for img in data['images']]

# Usage
urls = generate_image(
    'An editorial product photograph of a ceramic coffee mug, '
    'warm morning light, minimalist composition'
)
print(urls)

cURL

curl -X POST https://api.arteza.ai/v1/images/generate \
  -H "Authorization: Bearer $SEEDANCE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-v4-5",
    "prompt": "A futuristic city skyline at sunset, cinematic photography",
    "width": 2048,
    "height": 1152,
    "num_images": 1
  }'

Go

package main

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

type GenerateRequest struct {
    Model     string `json:"model"`
    Prompt    string `json:"prompt"`
    Width     int    `json:"width"`
    Height    int    `json:"height"`
    NumImages int    `json:"num_images"`
}

func generateImage(prompt string) (string, error) {
    reqBody := GenerateRequest{
        Model:     "seedream-v4-5",
        Prompt:    prompt,
        Width:     2048,
        Height:    2048,
        NumImages: 1,
    }

    jsonData, _ := json.Marshal(reqBody)
    req, _ := http.NewRequest(
        "POST",
        "https://api.arteza.ai/v1/images/generate",
        bytes.NewBuffer(jsonData),
    )
    req.Header.Set("Authorization", "Bearer "+os.Getenv("SEEDANCE_API_KEY"))
    req.Header.Set("Content-Type", "application/json")

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

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    images := result["images"].([]interface{})
    firstImage := images[0].(map[string]interface{})
    return firstImage["url"].(string), nil
}

Svarsformat

Lyckade svar returnerar JSON med denna struktur:

{
  "id": "gen_abc123xyz",
  "model": "seedream-v4-5",
  "created": 1712764800,
  "images": [
    {
      "url": "https://cdn.arteza.ai/gen/abc123.png",
      "width": 2048,
      "height": 2048,
      "seed": 42871
    }
  ],
  "credits_used": 8,
  "credits_remaining": 1042
}

Bild-URL:er är giltiga i 24 timmar. Ladda ned och lagra bilder omedelbar om du behöver permanent åtkomst.

Vill du ha detaljer som denna? Prova Seedream v4.5 gratis →

Redo att börja integrera? Hämta din API-nyckel →

Felhantering

API:t returnerar standard HTTP-statuskoder:

Exempel på felrespons:

{
  "error": {
    "code": "insufficient_credits",
    "message": "Your account has insufficient credits for this request",
    "credits_required": 8,
    "credits_available": 3
  }
}

Implementera alltid felhantering och försök igen för 429 och 500-fel. Försök inte igen på 400 och 401-fel - dessa kräver att du åtgärdar själva förfrågan.

Bästa praxis för produktionsanvändning

Hastighetsbegränsning

Standardhastighetsbegränsningar tillåter rimlig produktionsthroughput. Om du behöver högre gränser, kontakta supporten med dina användningsfall detaljer.

Implementera exponentiell backoff på 429-fel:

import time

def generate_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            return generate_image(prompt)
        except requests.HTTPError as e:
            if e.response.status_code == 429:
                wait_time = 2 ** attempt
                time.sleep(wait_time)
                continue
            raise
    raise Exception("Max retries exceeded")

Credithantering

Övervaka credits_remaining-fältet i varje svar. Ställ in varningar när saldot sjunker under ett tröskelvärde så att du kan fylla på innan produktionstrafiken träffar noll credits.

def check_credits(response):
    remaining = response.json().get('credits_remaining', 0)
    if remaining < 100:
        send_alert(f'Low credit warning: {remaining} credits')

Asynkron hantering

För användarvänd applikationer, behandla bildgenerering som asynkron. Blockera inte UI-tråden på ett 5-15 sekunds API-anrop. Mönster:

• Returnera ett jobb-ID omedelbar, avsökning för slutförande
• Använd webhooks (om stödd) för slutförandeaviseringar
• Generera spekulativt i bakgrunden och cachea resultat

Cachning

Genererade bilder är deterministiska givet samma prompt och frö. Cachelagra aggressivt efter prompt-hash för att undvika att regenerera identiska bilder.

import hashlib

def prompt_cache_key(prompt, width, height, seed):
    raw = f'{prompt}|{width}x{height}|{seed}'
    return hashlib.sha256(raw.encode()).hexdigest()

Promptsäkerhet

Om din app exponerar prompter för slutanvändare, implementera innehållsfiltrering innan du skickar till API:t. Arteza har innehållsprinciper - prompter som bryter mot dem returnerar fel, slösar credits och skapar användarvänd misslyckanden.

Prissättning för API-användning

API-användning drar från ditt kontos creditsaldo till samma kurs som webbanvändning.

Credits kommer från samma prispaket oavsett om du använder dem via webben eller API:t:

• Starter: $10 = 1 050 credits = ~131 bilder
• Popular: $25 = 2 750 credits = ~343 bilder
• Creator: $50 = 5 750 credits = ~718 bilder
• Studio: $100 = 12 000 credits = ~1 500 bilder

Högre volymkunder kan kontakta supporten om volymprissättning för försäljning över 100 000 bilder/månad.

Kombinera med andra Arteza-modeller

Din applikation kan använda flera Seedance-modeller genom samma API genom att ändra model-parametern:

• seedream-v4-5 - 8 credits - flaggskeppskvalitet
• seedream-v3 - 6 credits - snabbare, enklare
• seedream-5-lite - 7 credits - djupänkningsmodus
• seedream-5-edit - 7 credits - bildredigering
• seedance-2 - videogenerering (annat slutpunkt)

För applikationer som behöver redigeringsfunktioner utöver generering, hanterar seedream-5-edit textbaserad bildredigering. Se Seedream 5 Edit dokumentation för detaljer.

Säkerhetshänsyn

Exponera aldrig API-nycklar på klientsidan. Dirigera alltid API-anrop genom din backend. Exponerade nycklar kan användas för att tömma ditt creditsaldo.

Rotera nycklar regelbundet. Om en nyckel är komprometterad, återkalla den och generera en ny.

Loggförfrågningar för felsökning. Inkludera förfrågan-ID:n i dina loggar så att du kan korrelera misslyckanden med API-svar.

Implementera användningskvot per användare. Om din app erbjuder AI-generering som en funktion, begränsa per-användarkonsumtion för att förhindra missbruk.

Vanliga frågor

Finns det en fri nivå för API:t? Dina 50 registreringscredits fungerar på API-anrop. Det är 6 gratis Seedream v4.5-generering för att testa integration innan du betalar.

Vad är den typiska svarstiden? 5-15 sekunder för Seedream v4.5 beroende på upplösning och aktuell belastning.

Kan jag använda API:t för kommersiella produkter? Ja. Kommersiell användning ingår. Dina kunders genererade bilder är deras att använda för alla legitima ändamål.

Finns det ett Python SDK? Officiella SDK:er är under utveckling. Den nuvarande REST API fungerar rent med standard HTTP-bibliotek på vilket språk som helst.

Hur hanterar jag innehållsprincipfel? Implementera användarvänd meddelanden som förklarar att prompten avvisades. Loggade det specifika felet för felsökning.

Vad händer om mina credits tar slut mitt i en förfrågan? API:t returnerar ett 402-fel innan generering startar. Partiella avgifter förekommer aldrig - du får antingen hela bilden eller ett fel.

Kan jag batch flera prompter i en förfrågan? Icke direkt. Använd num_images: 6 för att få variationer av samma prompt, eller gör parallella API-anrop för olika prompter.

---

Seedream v4.5 API ger dig produktionsklar AI-bildgenerering till förutsägbar per-bild-prissättning med standard REST-konventioner. För de flesta integreringar kan du gå från API-nyckel till första fungerande generering på under 10 minuter. För frågor eller volymprissättning, nå ut genom ditt kontokontrollpanel.

Börja integrera idag. Hämta din API-nyckel → | Se fullständig prissättning → | Läs v4.5-guiden →