> 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.

# Szybki start z szablonami

W tym poradniku uruchomisz publiczny szablon ze skryptu w Pythonie lub TypeScripcie. Szablon zamienia zwykłe zdjęcie ubrania z telefonu w czyste zdjęcie produktowe, a skrypt zapisuje wynik obok niego. Poradnik zajmie około pięciu minut, a samo uruchomienie mniej niż minutę.

![Zdjęcie z telefonu i packshot](/docs/_fern-img/6afed41d4d791df68c87f183bd8db1d4aca8b4be3e946cc518534bda902f9528.webp)

**Szablon** to opublikowany [Flow ElevenCreative](/docs/pl/eleven-creative/products/flows): łańcuch modeli, który przyjmuje stały zestaw **danych wejściowych** i tworzy stały zestaw **danych wyjściowych**. Szablon, który uruchomisz — [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy) — przyjmuje jeden obraz i zwraca jeden obraz. Jego autor wybrał już modele i prompty, więc twój kod przekazuje tylko zdjęcie.

> **Warning**
>
> Uruchamianie szablonów wymaga planu Pro lub wyższego.

## Konfiguracja

#### Utwórz klucz API

[Utwórz klucz API w panelu tutaj](https://elevenlabs.io/app/settings/api-keys), aby bezpiecznie [uzyskać dostęp do API](/docs/pl/api-reference/authentication).

Przechowuj klucz jako zarządzany sekret i przekaż go do SDK jako zmienną środowiskową przez plik `.env` lub bezpośrednio w konfiguracji aplikacji — zależnie od preferencji.

**`.env`**

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

Nadaj kluczowi uprawnienie **Image & Video**.

#### Zainstaluj SDK

#### SDK

Użyjemy też biblioteki `dotenv`, aby wczytać klucz API ze zmiennej środowiskowej.

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

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

#### CLI

Zainstaluj CLI ElevenLabs. Zalecamy Homebrew (macOS) lub Scoop (Windows).

**`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**
>
> Pracujesz z asystentem AI do kodowania? Uruchom `elevenlabs generate-skills` w projekcie, aby zapisać
> `SKILL.md` dla każdej grupy poleceń w `skills/`. Dzięki temu asystent zna pełny zakres CLI
> bez wklejania dokumentacji. Użyj `--output-dir`, aby zapisać je w innym miejscu. Polecenie odczytuje
> wbudowaną definicję API CLI, więc nie potrzebuje klucza API i działa offline — oraz jest zgodne
> z zainstalowaną wersją CLI.

Następnie się uwierzytelnij — otworzy się przeglądarka, aby autoryzować CLI:

```bash
elevenlabs auth login
```

#### Pobierz zdjęcie

Pobierz przykładowe zdjęcie do folderu, w którym utworzysz skrypt:

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

## Znajdź kod szablonu

Otwórz [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy) w aplikacji ElevenLabs i wybierz kartę **API**. Każdy szablon ją ma — zawiera kod do jego uruchomienia w cURL, Pythonie i TypeScripcie.

![Karta API szablonu](/docs/_fern-img/801c9d2e2736964b35f5bad954092c973b21eedc03801128f1ed8bf31ea095b1.webp)

Karta prowadzi przez trzy kroki: pobranie klucza API, wybór sposobu odbioru wyniku i uruchomienie szablonu. W sekcji **Choose how to get the result** domyślnie wybrano **Wait for the result**. Kod w trzecim kroku otwiera się w cURL — wybierz **Python** lub **TypeScript**, a krok zmieni się na **Run and wait for the result**. Jego fragment uruchamia proces, czeka na jego zakończenie i wypisuje każde wyjście. Przekazuje po jednej wartości w `inputs` dla każdego wejścia szablonu, oznaczonej identyfikatorem wejścia, a każdy wynik odczytuje z `outputs` według identyfikatora wyjścia. Ten szablon ma jedno wejście, `garment_photo`, i jedno wyjście, `packshot`. To jedyne nazwy, których potrzebuje twój kod.

## Uruchom szablon

Utwórz `packshot.py` lub `packshot.mts`. To fragment z karty API z tymi zmianami:

* Klucz API jest wczytywany z pliku `.env`.
* Zdjęcie jest przekazywane jako base64 zamiast `YOUR_ASSET_ID`, czyli identyfikatora pliku przesłanego już do ElevenLabs.
* Skrypt wypisuje komunikat podczas działania procesu i zapisuje packshot jako `packshot.jpg` zamiast wypisywać jego URL.

**`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` w TypeScripcie) uruchamia proces, a następnie sprawdza go w interwale sugerowanym przez API, aż zakończą się wszystkie wyjścia. Zakończony błędem proces jest zwracany, a nie zgłaszany jako wyjątek, więc skrypt sprawdza `status` wyjścia przed jego odczytem. `version_id` przypina wersję szablonu, dla której napisano ten poradnik, więc późniejsza edycja szablonu nie zepsuje skryptu.

Uruchom skrypt. Uruchomienie tego szablonu zużywa około 1020 kredytów — tyle samo, co w aplikacji.

```python
python packshot.py
```

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

Po 30 sekundach do minuty skrypt wypisze:

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

Otwórz `packshot.jpg`. Ubranie ze zdjęcia jest teraz na manekinie, na jednolitym tle studyjnym — bez łóżka i oświetlenia.

> **Note**
>
> `create_and_wait` służy do skryptów i testowania szablonów. W środowisku produkcyjnym odbieraj
> zakończone procesy przez [webhook](/docs/pl/eleven-api/guides/how-to/image-and-video/webhooks), aby twoja
> aplikacja nie utrzymywała otwartego żądania podczas działania procesu. Zobacz, jak [uruchomić szablon swojego zespołu](/docs/pl/eleven-api/guides/how-to/templates/run-a-template).

## Uruchom z własnym zdjęciem

Zrób telefonem zdjęcie dowolnego ubrania. Nie musi być dobre: wystarczy t-shirt na łóżku lub kurtka przewieszona przez krzesło. Zapisz je jako JPEG pod nazwą `garment.jpg` i uruchom skrypt ponownie.

Otrzymasz packshot swojego ubrania w tym samym studyjnym stylu, ponieważ każde uruchomienie szablonu przechodzi przez te same modele i ustawienia. Szczegóły mogą się jednak różnić między uruchomieniami, nawet dla tego samego zdjęcia.

## Czego się nauczysz

* Szablon przyjmuje nazwane **dane wejściowe** i tworzy nazwane **dane wyjściowe**, a jego karta **API** pokazuje kod, który go uruchamia.
* `flows.templates.runs.create_and_wait` rozpoczyna **proces** z jedną wartością dla każdego identyfikatora wejścia i zwraca wynik po jego zakończeniu. Każde wyjście odczytujesz według jego identyfikatora i sprawdzasz jego `status`.
* W środowisku produkcyjnym każdy zakończony proces dostarcza **webhook**, więc nic na niego nie czeka.

## Kolejne kroki

#### [Uruchom szablon swojego zespołu](/docs/pl/eleven-api/guides/how-to/templates/run-a-template)

Skopiuj kod szablonu z jego karty API, uzupełnij każdy rodzaj danych wejściowych, odbierz wynik przez
webhook i przypnij wersję.

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

Skonfiguruj webhook produkcyjny, ręcznie weryfikuj podpisy oraz obsługuj ponowne próby i zduplikowane zdarzenia.

#### [Utwórz szablon](/docs/pl/eleven-creative/products/flows#creating-a-template)

Dowiedz się, jak zespół zmienia Flow w szablon: wybiera jego dane wejściowe i wyjściowe oraz go udostępnia.

#### [Dokumentacja API](/docs/pl/api-reference/flows/templates/runs/create)

Wszystkie parametry uruchomienia szablonu.