> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Schnellstart für Templates

In diesem Tutorial führen Sie ein öffentliches Template über ein Python- oder TypeScript-Skript aus. Das Template verwandelt ein spontanes Handyfoto eines Kleidungsstücks in eine saubere Produktaufnahme, und das Skript speichert das Ergebnis daneben. Das Tutorial dauert etwa fünf Minuten, davon der eigentliche Lauf weniger als eine Minute.

![Handyfoto und Produktaufnahme](/docs/_fern-img/6afed41d4d791df68c87f183bd8db1d4aca8b4be3e946cc518534bda902f9528.webp)

Ein **Template** ist ein veröffentlichtes [ElevenCreative Flow](/docs/de/eleven-creative/products/flows): eine Kette von Modellen, die eine feste Anzahl von **Eingaben** annimmt und eine feste Anzahl von **Ausgaben** erzeugt. Das Template, das Sie ausführen werden, [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy), nimmt ein Bild entgegen und gibt ein Bild zurück. Der Autor hat Modelle und Prompts bereits ausgewählt, daher übergibt Ihr Code nur das Foto.

> **Warning**
>
> Zum Ausführen eines Templates benötigen Sie einen Pro-Tarif oder höher.

## Einrichtung

#### API-Schlüssel erstellen

[Erstellen Sie hier im Dashboard einen API-Schlüssel](https://elevenlabs.io/app/settings/api-keys), den Sie für den sicheren [Zugriff auf die API](/docs/de/api-reference/authentication) verwenden.

Speichern Sie den Schlüssel als verwaltetes Secret und übergeben Sie ihn je nach Präferenz an die SDKs entweder als Umgebungsvariable über eine `.env`-Datei oder direkt in der Konfiguration Ihrer App.

**`.env`**

```js title=".env"
ELEVENLABS_API_KEY=<your_api_key_here>
```

Geben Sie dem Schlüssel die Berechtigung **Image & Video**.

#### SDK installieren

#### SDK

Wir verwenden außerdem die Bibliothek `dotenv`, um unseren API-Schlüssel aus einer Umgebungsvariable zu laden.

```python
pip install elevenlabs
pip install python-dotenv
```

```typescript
npm install @elevenlabs/elevenlabs-js
npm install dotenv
```

#### CLI

Installieren Sie die ElevenLabs CLI. Homebrew (macOS) und Scoop (Windows) werden empfohlen.

**`Homebrew (macOS)`**

```bash title="Homebrew (macOS)"
brew install elevenlabs/tap/elevenlabs
```

**`Scoop (Windows)`**

```powershell title="Scoop (Windows)"
scoop bucket add elevenlabs https://github.com/elevenlabs/scoop-bucket
scoop install elevenlabs
```

**`npm`**

```bash title="npm"
npm install -g @elevenlabs/cli
```

**`curl`**

```bash title="curl"
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/elevenlabs/cli/releases/latest/download/elevenlabs-cli-installer.sh | sh
```

> **Tip**
>
> Arbeiten Sie mit einem KI-Coding-Assistenten? Führen Sie in Ihrem Projekt `elevenlabs generate-skills` aus, um für jede Befehlsgruppe eine
> `SKILL.md` in `skills/` zu schreiben. So kennt Ihr Assistent den gesamten Funktionsumfang der CLI,
> ohne dass Sie Dokumentation einfügen müssen. Mit `--output-dir` können Sie sie an einem anderen Ort ablegen. Dies liest die eigene
> eingebettete API-Definition der CLI, benötigt also keinen API-Schlüssel und funktioniert offline — und bleibt mit
> der von Ihnen installierten CLI-Version synchron.

Authentifizieren Sie sich anschließend — dadurch wird Ihr Browser geöffnet, um die CLI zu autorisieren:

```bash
elevenlabs auth login
```

#### Foto abrufen

Laden Sie das Beispielfoto in den Ordner herunter, in dem Sie Ihr Skript erstellen werden:

```bash
curl -o garment.jpg https://storage.googleapis.com/eleven-public-cdn/documentation_assets/templates/garment.jpg
```

## Code des Templates finden

Öffnen Sie [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy) in der ElevenLabs-App und wählen Sie den Tab **API**. Jedes Template hat einen solchen Tab mit dem Code zum Ausführen in cURL, Python und TypeScript.

![API-Tab des Templates](/docs/_fern-img/801c9d2e2736964b35f5bad954092c973b21eedc03801128f1ed8bf31ea095b1.webp)

Der Tab führt durch drei Schritte: API-Schlüssel abrufen, Art des Ergebnisabrufs auswählen und Template ausführen. Unter **Choose how to get the result** ist standardmäßig **Wait for the result** ausgewählt. Der Code im dritten Schritt wird in cURL geöffnet. Wählen Sie **Python** oder **TypeScript**, dann wird der Schritt zu **Run and wait for the result**. Das Snippet startet einen Lauf, wartet auf dessen Abschluss und gibt jede Ausgabe aus. Es übergibt für jede Eingabe des Templates einen Wert unter `inputs`, wobei der Schlüssel die ID der Eingabe ist, und liest jedes Ergebnis anhand der Ausgabe-ID aus `outputs`. Dieses Template hat eine Eingabe, `garment_photo`, und eine Ausgabe, `packshot`. Diese beiden IDs sind die einzigen Namen, die Ihr Code benötigt.

## Template ausführen

Erstellen Sie `packshot.py` oder `packshot.mts`. Es ist das Snippet aus dem API-Tab mit diesen Änderungen:

* Der API-Schlüssel wird aus Ihrer `.env`-Datei geladen.
* Das Foto wird als Base64 anstelle von `YOUR_ASSET_ID`, der ID einer bereits zu ElevenLabs hochgeladenen Datei, übergeben.
* Das Skript gibt während des Laufs eine Zeile aus und speichert die Produktaufnahme in `packshot.jpg`, statt ihre URL auszugeben.

**`packshot.py`**

```python title="packshot.py" maxLines=0
import base64
import os
import urllib.request

from dotenv import load_dotenv
from elevenlabs import ElevenLabs, TemplateInputReference_InlineBase64

load_dotenv()

client = ElevenLabs(api_key=os.environ["ELEVENLABS_API_KEY"])

with open("garment.jpg", "rb") as f:
    photo = base64.b64encode(f.read()).decode()

print("Running the template, this takes up to a minute...")

# Starts a run and waits for it to finish, checking back as often as the API
# asks. In production, receive the result by webhook instead.
run = client.flows.templates.runs.create_and_wait(
    template_id="Yz4DETxRv4uXyIo5PnEy",
    # Pins the version this tutorial was written against.
    version_id="Kqs4nRrpndEjQ54BhbwE",
    inputs={
        "garment_photo": TemplateInputReference_InlineBase64(
            content_base_64=photo,
            mime_type="image/jpeg",
        ),
    },
)

packshot = run.outputs["packshot"]
# Checking `type` tells your editor this output is an image, which has a content_url.
if packshot.type == "image" and packshot.status == "completed" and packshot.content_url:
    urllib.request.urlretrieve(packshot.content_url, "packshot.jpg")
    print("Saved packshot.jpg")
else:
    print("The run failed:", packshot.failure_reason)

```

**`packshot.mts`**

```typescript title="packshot.mts" maxLines=0
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import "dotenv/config";
import { readFile, writeFile } from "fs/promises";

const client = new ElevenLabsClient({
  apiKey: process.env.ELEVENLABS_API_KEY,
});

const photo = await readFile("garment.jpg");

console.log("Running the template, this takes up to a minute...");

// Starts a run and waits for it to finish, checking back as often as the API
// asks. In production, receive the result by webhook instead.
const run = await client.flows.templates.runs.createAndWait("Yz4DETxRv4uXyIo5PnEy", {
  // Pins the version this tutorial was written against.
  versionId: "Kqs4nRrpndEjQ54BhbwE",
  inputs: {
    garment_photo: {
      type: "inline_base64",
      contentBase64: photo.toString("base64"),
      mimeType: "image/jpeg",
    },
  },
});

const packshot = run.outputs["packshot"];
// Checking `type` tells TypeScript this output is an image, which has a contentUrl.
if (packshot.type === "image" && packshot.status === "completed" && packshot.contentUrl) {
  const response = await fetch(packshot.contentUrl);
  await writeFile("packshot.jpg", Buffer.from(await response.arrayBuffer()));
  console.log("Saved packshot.jpg");
} else {
  console.error("The run failed:", packshot.failureReason);
}

```

`create_and_wait` (`createAndWait` in TypeScript) startet den Lauf und prüft ihn dann in dem von der API vorgeschlagenen Intervall, bis jede Ausgabe abgeschlossen ist. Ein fehlgeschlagener Lauf wird zurückgegeben, nicht ausgelöst. Daher prüft das Skript den `status` der Ausgabe, bevor es sie liest. `version_id` fixiert die Version des Templates, auf die sich dieses Tutorial bezieht, sodass eine spätere Änderung am Template das Skript nicht beeinträchtigen kann.

Führen Sie das Skript aus. Ein Lauf dieses Templates verbraucht etwa 1.020 Credits, genauso wie die Ausführung in der App.

```python
python packshot.py
```

```typescript
npx tsx packshot.mts
```

Nach 30 Sekunden bis einer Minute gibt das Skript Folgendes aus:

```text
Running the template, this takes up to a minute...
Saved packshot.jpg
```

Öffnen Sie `packshot.jpg`. Das Kleidungsstück auf dem Foto befindet sich jetzt auf einer Schaufensterpuppe vor einem schlichten Studiohintergrund. Bett und Beleuchtung sind verschwunden.

> **Note**
>
> `create_and_wait` ist für Skripte und zum Ausprobieren von Templates gedacht. In der Produktion
> sollten Sie abgeschlossene Läufe stattdessen über einen [Webhook](/docs/de/eleven-api/guides/how-to/image-and-video/webhooks) empfangen, damit Ihre
> Anwendung keine Anfrage offen hält, während ein Lauf ausgeführt wird. [Template Ihres Teams ausführen](/docs/de/eleven-api/guides/how-to/templates/run-a-template) zeigt, wie das geht.

## Mit Ihrem eigenen Foto ausführen

Fotografieren Sie ein beliebiges Kleidungsstück mit Ihrem Handy. Das Foto muss nicht gut sein: Ein T-Shirt auf Ihrem Bett oder eine Jacke über einem Stuhl genügt. Speichern Sie es als JPEG unter `garment.jpg` und führen Sie das Skript erneut aus.

Sie erhalten eine Produktaufnahme Ihres Kleidungsstücks im gleichen Studio-Look, da jeder Lauf eines Templates dieselben Modelle und Einstellungen durchläuft. Die Details können trotzdem von Lauf zu Lauf variieren, auch mit demselben Foto.

## Was Sie gelernt haben

* Ein Template nimmt benannte **Eingaben** entgegen und erzeugt benannte **Ausgaben**. Sein Tab **API** zeigt den Code zum Ausführen.
* `flows.templates.runs.create_and_wait` startet einen **Lauf** mit einem Wert pro Eingabe-ID und gibt ihn nach Abschluss zurück. Sie lesen jede Ausgabe anhand ihrer ID und prüfen ihren `status`.
* In der Produktion liefert ein **Webhook** jeden abgeschlossenen Lauf, sodass nichts darauf wartet.

## Nächste Schritte

#### [Template Ihres Teams ausführen](/docs/de/eleven-api/guides/how-to/templates/run-a-template)

Kopieren Sie den Code eines Templates aus seinem API-Tab, füllen Sie jede Art von Eingabe aus,
empfangen Sie das Ergebnis per Webhook und fixieren Sie eine Version.

#### [Webhooks](/docs/de/eleven-api/guides/how-to/image-and-video/webhooks)

Richten Sie einen Webhook für die Produktion ein, prüfen Sie Signaturen manuell und behandeln Sie Wiederholungen und doppelte Ereignisse.

#### [Template erstellen](/docs/de/eleven-creative/products/flows#creating-a-template)

So macht Ihr Team aus einem Flow ein Template: Eingaben und Ausgaben auswählen und es teilen.

#### [API-Referenz](/docs/de/api-reference/flows/templates/runs/create)

Alle Parameter eines Template-Laufs.