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

# Guide de démarrage rapide des templates

Dans ce tutoriel, vous exécuterez un template public depuis un script Python ou TypeScript. Le template transforme une photo décontractée prise au téléphone d'un vêtement en packshot propre, puis le script enregistre le résultat à côté. Le tutoriel dure environ cinq minutes, dont moins d'une minute pour l'exécution elle-même.

![Photo prise au téléphone et packshot](/docs/_fern-img/6afed41d4d791df68c87f183bd8db1d4aca8b4be3e946cc518534bda902f9528.webp)

Un **template** est un [ElevenCreative Flow](/docs/fr/eleven-creative/products/flows) publié : une chaîne de modèles qui reçoit un ensemble fixe d'**entrées** et produit un ensemble fixe de **sorties**. Celui que vous allez exécuter, [Photo prise au téléphone vers packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy), reçoit une image et renvoie une image. Son auteur a déjà choisi les modèles et les prompts, votre code n'a donc qu'à transmettre la photo.

> **Warning**
>
> L'exécution d'un template requiert un forfait Pro ou supérieur.

## Configuration

#### Créer une clé API

[Créez une clé API dans le Dashboard ici](https://elevenlabs.io/app/settings/api-keys), que vous utiliserez pour [accéder à l'API](/docs/fr/api-reference/authentication) de manière sécurisée.

Stockez la clé comme secret géré et transmettez-la aux SDK soit en tant que variable d'environnement via un fichier `.env`, soit directement dans la configuration de votre application, selon vos préférences.

**`.env`**

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

Attribuez à la clé l'autorisation **Image & Vidéo**.

#### Installer le SDK

#### SDK

Nous utiliserons également la bibliothèque `dotenv` pour charger notre clé API depuis une variable d'environnement.

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

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

#### CLI

Installez la CLI ElevenLabs. Homebrew (macOS) et Scoop (Windows) sont recommandés.

**`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**
>
> Vous travaillez avec un assistant de programmation IA ? Exécutez `elevenlabs generate-skills` dans votre projet pour créer un
> fichier `SKILL.md` pour chaque groupe de commandes dans `skills/`, afin que votre assistant connaisse toutes les fonctionnalités de la CLI
> sans que vous ayez à copier la documentation. Utilisez `--output-dir` pour les placer ailleurs. Cette commande lit la propre
> définition d'API intégrée à la CLI, elle ne nécessite donc aucune clé API et fonctionne hors ligne, tout en restant synchronisée avec
> la version de la CLI que vous avez installée.

Authentifiez-vous ensuite, votre navigateur s'ouvrira pour autoriser la CLI :

```bash
elevenlabs auth login
```

#### Obtenir une photo

Téléchargez l'exemple de photo dans le dossier où vous créerez votre script :

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

## Trouver le code du template

Ouvrez [Photo prise au téléphone vers packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy) dans l'application ElevenLabs et sélectionnez l'onglet **API**. Chaque template en possède un, avec le code permettant de l'exécuter en cURL, Python et TypeScript.

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

L'onglet présente trois étapes : obtenir une clé API, choisir comment obtenir le résultat et exécuter le template. Sous **Choisir comment obtenir le résultat**, l'option **Attendre le résultat** est sélectionnée par défaut. Le code de la troisième étape s'ouvre sur cURL ; sélectionnez **Python** ou **TypeScript**, et l'étape devient **Exécuter et attendre le résultat**. Son extrait démarre une exécution, attend qu'elle se termine et affiche chaque sortie. Il transmet une valeur sous `inputs` pour chacune des entrées du template, identifiée par l'id de l'entrée, et lit chaque résultat depuis `outputs` à l'aide de l'id de la sortie. Ce template possède une entrée, `garment_photo`, et une sortie, `packshot`. Ces deux id sont les seuls noms dont votre code a besoin.

## Exécuter le template

Créez `packshot.py` ou `packshot.mts`. Il s'agit de l'extrait de l'onglet API avec les modifications suivantes :

* La clé API est chargée depuis votre fichier `.env`.
* La photo est transmise en base64 à la place de `YOUR_ASSET_ID`, l'id d'un fichier déjà importé dans ElevenLabs.
* Le script affiche une ligne pendant l'exécution et enregistre le packshot dans `packshot.jpg` au lieu d'afficher son 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` en TypeScript) démarre l'exécution, puis vérifie son état à l'intervalle suggéré par l'API jusqu'à ce que chaque sortie soit terminée. Une exécution qui échoue est renvoyée, sans lever d'exception ; le script vérifie donc le `status` de la sortie avant de la lire. `version_id` fige la version du template utilisée pour rédiger ce tutoriel, afin qu'une modification ultérieure du template ne puisse pas casser le script.

Exécutez le script. Une exécution de ce template utilise environ 1 020 crédits, comme dans l'application.

```python
python packshot.py
```

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

Après 30 secondes à une minute, le script affiche :

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

Ouvrez `packshot.jpg`. Le vêtement de la photo est désormais sur un mannequin devant un fond de studio uni ; le lit et l'éclairage ont disparu.

> **Note**
>
> `create_and_wait` est destiné aux scripts et aux essais de templates. En production, recevez plutôt les exécutions terminées
> avec un [webhook](/docs/fr/eleven-api/guides/how-to/image-and-video/webhooks), afin que votre
> application ne conserve pas une requête ouverte pendant une exécution. [Exécuter le template de votre équipe](/docs/fr/eleven-api/guides/how-to/templates/run-a-template) explique comment procéder.

## L'exécuter avec votre propre photo

Prenez avec votre téléphone une photo de n'importe quel vêtement. Elle n'a pas besoin d'être réussie : un t-shirt sur votre lit ou une veste sur une chaise conviennent. Enregistrez-la en JPEG sous `garment.jpg` et exécutez à nouveau le script.

Vous obtenez un packshot de votre vêtement avec le même rendu studio, car chaque exécution d'un template passe par les mêmes modèles et réglages. Les détails peuvent toutefois varier d'une exécution à l'autre, même avec la même photo.

## Ce que vous avez appris

* Un template reçoit des **entrées** nommées et produit des **sorties** nommées, et son onglet **API** affiche le code permettant de l'exécuter.
* `flows.templates.runs.create_and_wait` démarre une **exécution** avec une valeur par id d'entrée et renvoie le résultat une fois terminée. Vous lisez chaque sortie à l'aide de son id et vérifiez son `status`.
* En production, un **webhook** transmet chaque exécution terminée, sans que rien n'ait à l'attendre.

## Étapes suivantes

#### [Exécuter le template de votre équipe](/docs/fr/eleven-api/guides/how-to/templates/run-a-template)

Copiez le code d'un template depuis son onglet API, renseignez chaque type d'entrée, recevez le résultat par
webhook et figez une version.

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

Configurez un webhook de production, vérifiez manuellement les signatures et gérez les nouvelles tentatives et les événements dupliqués.

#### [Créer un template](/docs/fr/eleven-creative/products/flows#creating-a-template)

Découvrez comment votre équipe transforme un Flow en template : choix de ses entrées et sorties, puis partage.

#### [Guide de l'API](/docs/fr/api-reference/flows/templates/runs/create)

Tous les paramètres d'une exécution de template.