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

# Guida rapida ai template

In questo tutorial eseguirai un template pubblico da uno script Python o TypeScript. Il template trasforma una foto informale di un capo di abbigliamento scattata con il telefono in una pulita foto prodotto, e lo script salva il risultato accanto all'originale. Il tutorial richiede circa cinque minuti, di cui l'esecuzione stessa dura meno di un minuto.

![Foto da telefono e packshot](/docs/_fern-img/6afed41d4d791df68c87f183bd8db1d4aca8b4be3e946cc518534bda902f9528.webp)

Un **template** è un [ElevenCreative Flow](/docs/it/eleven-creative/products/flows) pubblicato: una catena di modelli che riceve un insieme fisso di **input** e produce un insieme fisso di **output**. Quello che eseguirai, [Foto da telefono a packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy), riceve un'immagine e restituisce un'immagine. Il suo autore ha già scelto i modelli e i prompt, quindi il tuo codice deve solo passare la foto.

> **Warning**
>
> Per eseguire un template è necessario un piano Pro o superiore.

## Configurazione

#### Crea una chiave API

[Crea qui una chiave API nella dashboard](https://elevenlabs.io/app/settings/api-keys), che userai per [accedere all'API](/docs/it/api-reference/authentication) in modo sicuro.

Archivia la chiave come secret gestito e passala agli SDK come variabile d'ambiente tramite un file `.env` oppure direttamente nella configurazione della tua app, a seconda delle tue preferenze.

**`.env`**

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

Assegna alla chiave l'autorizzazione **Immagini e Video**.

#### Installa l'SDK

#### SDK

Useremo anche la libreria `dotenv` per caricare la nostra chiave API da una variabile d'ambiente.

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

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

#### CLI

Installa la CLI di ElevenLabs. Consigliamo Homebrew (macOS) e 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**
>
> Lavori con un assistente di coding IA? Esegui `elevenlabs generate-skills` nel tuo progetto per creare un
> file `SKILL.md` per ogni gruppo di comandi in `skills/`, così il tuo assistente conosce tutte le funzionalità della CLI
> senza che tu debba incollare la documentazione. Usa `--output-dir` per inserirli altrove. Il comando legge la definizione API
> integrata della CLI, quindi non richiede una chiave API e funziona offline — inoltre rimane allineato
> alla versione della CLI che hai installato.

Poi autentica la CLI: si aprirà il browser per autorizzarla.

```bash
elevenlabs auth login
```

#### Scarica una foto

Scarica la foto di esempio nella cartella in cui creerai lo script:

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

## Trova il codice del template

Apri [Foto da telefono a packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy) nell'app ElevenLabs e seleziona la scheda **API**. Ogni template ne ha una, con il codice per eseguirlo in cURL, Python e TypeScript.

![Scheda API del template](/docs/_fern-img/801c9d2e2736964b35f5bad954092c973b21eedc03801128f1ed8bf31ea095b1.webp)

La scheda illustra tre passaggi: ottenere una chiave API, scegliere come ricevere il risultato ed eseguire il template. In **Scegli come ricevere il risultato**, l'opzione **Attendi il risultato** è selezionata per impostazione predefinita. Il codice del terzo passaggio si apre su cURL; seleziona **Python** o **TypeScript** e il passaggio diventa **Esegui e attendi il risultato**. Il relativo snippet avvia un'esecuzione, ne attende il completamento e stampa ogni output. Passa un valore in `inputs` per ogni input del template, identificato dall'id dell'input, e legge ogni risultato da `outputs` tramite l'id dell'output. Questo template ha un input, `garment_photo`, e un output, `packshot`. Questi due id sono gli unici nomi necessari al tuo codice.

## Esegui il template

Crea `packshot.py` o `packshot.mts`. È lo snippet della scheda API con queste modifiche:

* La chiave API viene caricata dal file `.env`.
* La foto viene passata come base64 al posto di `YOUR_ASSET_ID`, l'ID di un file già caricato su ElevenLabs.
* Lo script stampa una riga mentre l'esecuzione è in corso e salva il packshot in `packshot.jpg` invece di stamparne l'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` in TypeScript) avvia l'esecuzione, quindi ne verifica lo stato all'intervallo suggerito dall'API finché ogni output non è completato. Un'esecuzione non riuscita viene restituita, non sollevata, quindi lo script verifica lo `status` dell'output prima di leggerlo. `version_id` fissa la versione del template su cui è stato scritto questo tutorial, così una modifica successiva al template non può interrompere lo script.

Esegui lo script. Un'esecuzione di questo template usa circa 1.020 crediti, come eseguirlo nell'app.

```python
python packshot.py
```

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

Dopo 30 secondi o un minuto, lo script stampa:

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

Apri `packshot.jpg`. Il capo della foto ora è su un manichino davanti a un semplice sfondo da studio, senza il letto né l'illuminazione originale.

> **Note**
>
> `create_and_wait` è pensato per script e per provare i template. In produzione, ricevi invece le esecuzioni completate
> con un [webhook](/docs/it/eleven-api/guides/how-to/image-and-video/webhooks), così la tua
> applicazione non mantiene aperta una richiesta mentre un'esecuzione è in corso. [Esegui il template del tuo team](/docs/it/eleven-api/guides/how-to/templates/run-a-template) spiega come fare.

## Eseguilo con la tua foto

Scatta con il telefono una foto di qualsiasi capo di abbigliamento. Non deve essere una bella foto: va bene una t-shirt sul letto o una giacca appoggiata a una sedia. Salvala come JPEG sovrascrivendo `garment.jpg` ed esegui di nuovo lo script.

Otterrai un packshot del tuo capo con lo stesso stile da studio, perché ogni esecuzione di un template passa attraverso gli stessi modelli e le stesse impostazioni. I dettagli possono comunque variare tra un'esecuzione e l'altra, anche con la stessa foto.

## Cosa hai imparato

* Un template riceve **input** con nome e produce **output** con nome, e la sua scheda **API** mostra il codice per eseguirlo.
* `flows.templates.runs.create_and_wait` avvia un'**esecuzione** con un valore per ogni id di input e restituisce il risultato una volta completata. Leggi ogni output tramite il suo id e ne verifichi lo `status`.
* In produzione, un **webhook** consegna ogni esecuzione completata, quindi non è necessario attendere.

## Passaggi successivi

#### [Esegui il template del tuo team](/docs/it/eleven-api/guides/how-to/templates/run-a-template)

Copia il codice di un template dalla relativa scheda API, inserisci ogni tipo di input, ricevi il risultato tramite
webhook e fissa una versione.

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

Configura un webhook di produzione, verifica manualmente le firme e gestisci i tentativi e gli eventi duplicati.

#### [Crea un template](/docs/it/eleven-creative/products/flows#creating-a-template)

Scopri come il tuo team trasforma un Flow in un template: scegliendo input e output e condividendolo.

#### [Riferimento API](/docs/it/api-reference/flows/templates/runs/create)

Tutti i parametri di un'esecuzione di template.