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

# Kom igång med mallar

I den här guiden kör du en offentlig mall från ett Python- eller TypeScript-skript. Mallen förvandlar ett vanligt mobilfoto av ett klädesplagg till en ren produktbild, och skriptet sparar resultatet bredvid originalet. Guiden tar ungefär fem minuter, varav själva körningen tar mindre än en minut.

![Mobilfoto och produktbild](/docs/_fern-img/6afed41d4d791df68c87f183bd8db1d4aca8b4be3e946cc518534bda902f9528.webp)

En **mall** är ett publicerat [ElevenCreative Flow](/docs/sv/eleven-creative/products/flows): en kedja av modeller som tar en fast uppsättning **indata** och producerar en fast uppsättning **utdata**. Den du ska köra, [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy), tar en bild och returnerar en bild. Dess skapare har redan valt modellerna och prompterna, så din kod behöver bara skicka fotot.

> **Warning**
>
> För att köra en mall behöver du en Pro-plan eller högre.

## Konfigurera

#### Skapa en API-nyckel

[Skapa en API-nyckel i kontrollpanelen här](https://elevenlabs.io/app/settings/api-keys), som du använder för att säkert [få åtkomst till API:et](/docs/sv/api-reference/authentication).

Spara nyckeln som en hanterad hemlighet och skicka den till SDK:erna antingen som en miljövariabel via en `.env`-fil eller direkt i appens konfiguration, beroende på vad du föredrar.

**`.env`**

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

Ge nyckeln behörigheten **Image & Video**.

#### Installera SDK:t

#### SDK

Vi använder också biblioteket `dotenv` för att läsa in vår API-nyckel från en miljövariabel.

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

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

#### CLI

Installera ElevenLabs CLI. Homebrew (macOS) och Scoop (Windows) rekommenderas.

**`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**
>
> Arbetar du med en AI-kodningsassistent? Kör `elevenlabs generate-skills` i ditt projekt för att skapa en
> `SKILL.md` för varje kommandogrupp i `skills/`, så att assistenten känner till hela CLI:ts yta
> utan att du behöver klistra in dokumentation. Använd `--output-dir` för att lägga dem någon annanstans. Detta läser CLI:ts egen
> inbäddade API-definition, så det kräver ingen API-nyckel och fungerar offline — och det följer
> den version av CLI:t som du har installerad.

Autentisera sedan — detta öppnar webbläsaren så att du kan auktorisera CLI:t:

```bash
elevenlabs auth login
```

#### Hämta ett foto

Ladda ner exempelfotot till mappen där du ska skapa ditt skript:

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

## Hitta mallens kod

Öppna [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy) i ElevenLabs-appen och välj fliken **API**. Varje mall har en sådan, med kod för att köra den i cURL, Python och TypeScript.

![Mallens API-flik](/docs/_fern-img/801c9d2e2736964b35f5bad954092c973b21eedc03801128f1ed8bf31ea095b1.webp)

Fliken guidar dig genom tre steg: hämta en API-nyckel, välj hur du vill få resultatet och kör mallen. Under **Välj hur du vill få resultatet** är **Vänta på resultatet** valt som standard. Koden i det tredje steget öppnas i cURL; välj **Python** eller **TypeScript**, så blir steget **Kör och vänta på resultatet**. Kodexemplet startar en körning, väntar på att den ska bli klar och skriver ut varje utdata. Det skickar ett värde under `inputs` för var och en av mallens indata, med indatats id som nyckel, och läser varje resultat från `outputs` med utdatats id. Den här mallen har en indata, `garment_photo`, och en utdata, `packshot`. Dessa två id:n är de enda namn din kod behöver.

## Kör mallen

Skapa `packshot.py` eller `packshot.mts`. Det är kodexemplet från API-fliken med följande ändringar:

* API-nyckeln läses in från din `.env`-fil.
* Fotot skickas som base64 i stället för `YOUR_ASSET_ID`, id:t för en fil som redan har laddats upp till ElevenLabs.
* Skriptet skriver ut en rad medan körningen pågår och sparar produktbilden till `packshot.jpg` i stället för att skriva ut dess 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` i TypeScript) startar körningen och kontrollerar sedan statusen med det intervall som API:t föreslår tills alla utdata är klara. En körning som misslyckas returneras i stället för att kasta ett fel, så skriptet kontrollerar utdatats `status` innan det läser det. `version_id` låser versionen av mallen som den här guiden skrevs för, så att en senare ändring av mallen inte kan göra att skriptet slutar fungera.

Kör skriptet. En körning av den här mallen använder ungefär 1 020 krediter, samma som när du kör den i appen.

```python
python packshot.py
```

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

Efter 30 sekunder till en minut skriver skriptet ut:

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

Öppna `packshot.jpg`. Plagget från fotot är nu på en provdocka mot en enkel studiobakgrund, utan sängen och belysningen.

> **Note**
>
> `create_and_wait` är för skript och för att testa mallar. I produktion bör du i stället ta emot
> slutförda körningar med en [webhook](/docs/sv/eleven-api/guides/how-to/image-and-video/webhooks), så att din
> applikation inte håller en begäran öppen medan en körning pågår. [Kör ditt teams mall](/docs/sv/eleven-api/guides/how-to/templates/run-a-template) visar hur.

## Kör den med ditt eget foto

Ta ett foto av valfritt klädesplagg med mobilen. Det behöver inte vara ett bra foto: en t-shirt på sängen eller en jacka över en stol fungerar. Spara det som en JPEG ovanpå `garment.jpg` och kör skriptet igen.

Du får en produktbild av ditt plagg med samma studiokänsla, eftersom varje körning av en mall använder samma modeller och inställningar. Detaljerna kan ändå variera mellan körningar, även med samma foto.

## Det här har du lärt dig

* En mall tar namngivna **indata** och producerar namngivna **utdata**, och dess flik **API** visar koden som kör den.
* `flows.templates.runs.create_and_wait` startar en **körning** med ett värde per indata-id och returnerar när den är klar. Du läser varje utdata med dess id och kontrollerar dess `status`.
* I produktion levererar en **webhook** varje slutförd körning, så att inget behöver vänta på den.

## Nästa steg

#### [Kör ditt teams mall](/docs/sv/eleven-api/guides/how-to/templates/run-a-template)

Kopiera en malls kod från dess API-flik, fyll i varje typ av indata, ta emot resultatet via
webhook och lås en version.

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

Konfigurera en webhook för produktion, verifiera signaturer manuellt och hantera omförsök och dubbletthändelser.

#### [Skapa en mall](/docs/sv/eleven-creative/products/flows#creating-a-template)

Så förvandlar ditt team ett Flow till en mall: väljer dess indata och utdata och delar den.

#### [API-referens](/docs/sv/api-reference/flows/templates/runs/create)

Alla parametrar för en mallkörning.