> ## Documentation Index
> Fetch the complete documentation index at: https://docs.evolink.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Schnellintegration

> Mit EvoLink schnell Bild-, Video- und Textmodelle aufrufen

# Schnellintegration

Diese Anleitung hilft Ihnen, den ersten EvoLink-Aufruf in wenigen Minuten auszuführen. Multimodale Workloads verwenden asynchrone Aufgaben; Textmodelle verwenden eine synchrone Messages-API für Chat- und Coding-Tools.

<CardGroup cols={3}>
  <Card title="Bildgenerierung" icon="image" href="/de/api-manual/image-series/gpt-image-2/gpt-image-2-image-generation">
    Erstellen Sie mit GPT Image 2 eine Bildgenerierungsaufgabe und fragen Sie das Ergebnis über die Aufgaben-API ab.
  </Card>

  <Card title="Videogenerierung" icon="video" href="/de/api-manual/video-series/seedance2.0/seedance-2.0-overview">
    Erstellen Sie Text-zu-Video-, Bild-zu-Video- und Referenz-zu-Video-Aufgaben mit Seedance 2.0.
  </Card>

  <Card title="Textgenerierung" icon="comments" href="/de/api-manual/language-series/claude/claude-messages-api">
    Nutzen Sie die Claude Messages API, um synchrone Textantworten zu erhalten.
  </Card>
</CardGroup>

## Vorbereitung

<Steps>
  <Step title="API Key erstellen">
    Öffnen Sie das [EvoLink-Dashboard](https://evolink.ai/dashboard/keys), erstellen Sie einen API Key und speichern Sie ihn sicher.
  </Step>

  <Step title="Base URL wählen">
    Verwenden Sie `https://api.evolink.ai` für Bild-, Video-, Audio- und andere multimodale Aufgaben. Verwenden Sie `https://direct.evolink.ai` für Textmodelle.
  </Step>

  <Step title="Anfrage senden">
    Multimodale APIs geben zuerst eine Aufgaben-ID zurück. Text-APIs geben die Modellantwort direkt zurück.
  </Step>
</Steps>

<Warning>
  API Keys können Ressourcen Ihres Kontos aufrufen. Speichern Sie sie nur serverseitig oder in sicheren Umgebungsvariablen. Legen Sie Schlüssel nicht in Frontend-Code, öffentlichen Repositories oder Client-Paketen ab.
</Warning>

## Ablauf einer Anfrage

Multimodale Aufgaben verwenden denselben Ablauf:

<CardGroup cols={3}>
  <Card title="1. Aufgabe einreichen" icon="paper-plane">
    Rufen Sie einen Bild-, Video- oder Audio-Endpunkt auf und erhalten Sie die Aufgaben-ID im Antwortfeld `id`.
  </Card>

  <Card title="2. Status abfragen" icon="chart-line">
    Verwenden Sie `GET /v1/tasks/{task_id}`, um `pending`, `processing`, `completed` oder `failed` zu prüfen.
  </Card>

  <Card title="3. Ergebnisse abrufen" icon="download">
    Wenn die Aufgabe abgeschlossen ist, lesen Sie die generierte Datei-URL aus dem Feld `results`.
  </Card>
</CardGroup>

<Note>
  Generierte Bild- und Video-URLs laufen normalerweise ab. Laden Sie fertige Ergebnisse in Produktionsumgebungen möglichst schnell herunter und speichern Sie sie in Ihrem eigenen Speicher.
</Note>

## Bildgenerierung

Erstellen Sie eine Bildgenerierungsaufgabe mit GPT Image 2:

```bash theme={null}
curl -X POST https://api.evolink.ai/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2",
    "prompt": "Eine filmische Weitwinkelaufnahme einer futuristischen Skyline bei Abenddämmerung",
    "size": "16:9",
    "resolution": "4K",
    "quality": "high",
    "n": 1
  }'
```

Die Antwort enthält ein Aufgabenobjekt:

```json theme={null}
{
  "id": "task-unified-1757156493-imcg5zqt",
  "object": "image.generation.task",
  "model": "gpt-image-2",
  "status": "pending",
  "progress": 0,
  "task_info": {
    "can_cancel": true,
    "estimated_time": 100
  }
}
```

Status der Aufgabe abfragen:

```bash theme={null}
curl https://api.evolink.ai/v1/tasks/task-unified-1757156493-imcg5zqt \
  -H "Authorization: Bearer YOUR_API_KEY"
```

Nach Abschluss stehen die Ergebnisse im Array `results`:

```json theme={null}
{
  "id": "task-unified-1757156493-imcg5zqt",
  "object": "image.generation.task",
  "model": "gpt-image-2",
  "status": "completed",
  "progress": 100,
  "results": [
    "https://example.com/generated-image.png"
  ]
}
```

## Videogenerierung

Erstellen Sie eine Text-zu-Video-Aufgabe mit Seedance 2.0:

```bash theme={null}
curl -X POST https://api.evolink.ai/v1/videos/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-text-to-video",
    "prompt": "Eine Makroaufnahme fokussiert einen grünen Glasfrosch auf einem Blatt und wechselt dann zu seinem transparenten Bauch, in dem ein rotes Herz rhythmisch schlägt.",
    "duration": 8,
    "quality": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": true
  }'
```

Videoaufgaben werden über dieselbe Aufgaben-API abgefragt:

```bash theme={null}
curl https://api.evolink.ai/v1/tasks/YOUR_VIDEO_TASK_ID \
  -H "Authorization: Bearer YOUR_API_KEY"
```

<Tip>
  Für Bild-zu-Video oder Videoerstellung mit mehreren Referenzen starten Sie im [vollständigen Seedance 2.0 Parameterleitfaden](/de/api-manual/video-series/seedance2.0/seedance-2.0-overview).
</Tip>

## Textgenerierung

Claude-Textmodelle sollten `https://direct.evolink.ai` mit dem Endpunkt `/v1/messages` verwenden:

```bash theme={null}
curl -X POST https://direct.evolink.ai/v1/messages \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-20250929",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Stelle EvoLink in drei Sätzen vor"
      }
    ]
  }'
```

Die Text-API gibt synchron ein Message-Objekt zurück:

```json theme={null}
{
  "id": "msg_xxx",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-5-20250929",
  "content": [
    {
      "type": "text",
      "text": "EvoLink bietet ein einheitliches KI-Service-Gateway..."
    }
  ],
  "stop_reason": "end_turn"
}
```

## Python-Beispiel

Dieses Beispiel reicht eine Bildaufgabe ein, fragt den Status ab und liest das finale Ergebnis:

```python theme={null}
import os
import time
import requests

API_KEY = os.environ["EVOLINK_API_KEY"]
BASE_URL = "https://api.evolink.ai"

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


def create_image_task(prompt: str) -> str:
    response = requests.post(
        f"{BASE_URL}/v1/images/generations",
        headers=headers,
        json={
            "model": "gpt-image-2",
            "prompt": prompt,
            "size": "1:1",
            "quality": "high",
        },
        timeout=30,
    )
    response.raise_for_status()
    return response.json()["id"]


def wait_for_task(task_id: str, timeout_seconds: int = 300):
    started_at = time.time()

    while time.time() - started_at < timeout_seconds:
        response = requests.get(
            f"{BASE_URL}/v1/tasks/{task_id}",
            headers={"Authorization": f"Bearer {API_KEY}"},
            timeout=30,
        )
        response.raise_for_status()
        task = response.json()

        if task["status"] == "completed":
            return task["results"]
        if task["status"] == "failed":
            raise RuntimeError(task.get("error", "Task failed"))

        time.sleep(5)

    raise TimeoutError("Task timed out")


task_id = create_image_task("Ein klares Produktposter, weißer Hintergrund, weiches Studiolicht")
results = wait_for_task(task_id)
print(results[0])
```

## Anfragefrequenzlimits

Die Anfragefrequenzlimits von EvoLink werden pro Modell konfiguriert.

RPM, Parallelität und Limits für Aufgabeneinreichungen können je nach Modell unterschiedlich sein. Die tatsächlichen Limits hängen vom Modelltyp, der Kapazität des Upstream-Dienstes, der Kontostufe und der Echtzeitverfügbarkeit ab. Leichte Textmodelle unterstützen in der Regel höhere Anfragefrequenzen, während Bild- und Videogenerierungsmodelle niedrigere Limits haben können, da Aufgaben länger dauern und mehr Upstream-Ressourcen belegen.

Bei asynchronen Generierungsmodellen bedeutet eine erfolgreiche API-Antwort nur, dass die Aufgabe angenommen oder erstellt wurde; sie bedeutet nicht, dass die Aufgabe abgeschlossen ist. Für Workloads mit hoher Parallelität sollten Sie serverseitig eine Warteschlange implementieren und Endergebnisse über die Aufgabenabfrage-API oder Callbacks abrufen.

Wenn Sie wiederholt HTTP-429-Fehler erhalten oder Ihre Anwendung höhere RPM- oder Parallelitätslimits benötigt, kontaktieren Sie [support@evolink.ai](mailto:support@evolink.ai). Wir bewerten die Anfrage anhand des konkreten Anwendungsfalls und der Upstream-Kapazität.

## Empfehlungen für Produktion

<CardGroup cols={2}>
  <Card title="Schlüsselverwaltung" icon="shield">
    Speichern Sie API Keys in Umgebungsvariablen oder einem Secret Manager und verwenden Sie getrennte Schlüssel für unterschiedliche Umgebungen.
  </Card>

  <Card title="Aufgaben-Polling" icon="clock">
    Wählen Sie Polling-Intervalle passend zum Aufgabentyp. Bildaufgaben können häufiger abgefragt werden; Videoaufgaben sollten meist seltener abgefragt werden.
  </Card>

  <Card title="Fehlerbehandlung" icon="server">
    Behandeln Sie den Aufgabenstatus `failed` und HTTP-Fehler, einschließlich Frequenzlimits, unzureichendem Guthaben und Parameterfehlern.
  </Card>

  <Card title="Ergebnisspeicherung" icon="download">
    Ergebnis-URLs laufen ab. Laden Sie fertige Dateien in Produktionsumgebungen herunter und speichern Sie sie in Ihrem eigenen Speichersystem.
  </Card>
</CardGroup>

## Nächste Schritte

<CardGroup cols={3}>
  <Card title="Bild-API" icon="image" href="/de/api-manual/image-series/gpt-image-2/gpt-image-2-image-generation">
    GPT Image 2 Parameter, Beispiele und Antwortstruktur ansehen.
  </Card>

  <Card title="Video-API" icon="video" href="/de/api-manual/video-series/seedance2.0/seedance-2.0-overview">
    Seedance 2.0 Funktionen für Text-zu-Video, Bild-zu-Video und Referenz-zu-Video ansehen.
  </Card>

  <Card title="Aufgabenverwaltung" icon="list-check" href="/de/api-manual/task-management/get-task-detail">
    Statusabfragen, Ergebnisfelder und Fehlerstruktur für Aufgaben ansehen.
  </Card>
</CardGroup>