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

# Inicio rápido de plantillas

En este tutorial ejecutarás una plantilla pública desde un script de Python o TypeScript. La plantilla transforma una foto informal tomada con el móvil de una prenda de ropa en una imagen de producto limpia, y el script guarda el resultado junto a ella. El tutorial dura unos cinco minutos, y la ejecución en sí tarda menos de un minuto.

![Foto de móvil e imagen de producto](/docs/_fern-img/6afed41d4d791df68c87f183bd8db1d4aca8b4be3e946cc518534bda902f9528.webp)

Una **plantilla** es un [Flujo de ElevenCreative](/docs/es/eleven-creative/products/flows) publicado: una cadena de modelos que recibe un conjunto fijo de **entradas** y genera un conjunto fijo de **salidas**. La que ejecutarás, [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy), recibe una imagen y devuelve una imagen. Su autor ya ha elegido los modelos y los prompts, así que tu código solo pasa la foto.

> **Warning**
>
> Para ejecutar una plantilla necesitas un plan Pro o superior.

## Configuración

#### Crea una clave de API

[Crea una clave de API aquí, en el panel](https://elevenlabs.io/app/settings/api-keys), que usarás para [acceder a la API](/docs/es/api-reference/authentication) de forma segura.

Guarda la clave como un secreto gestionado y pásala a los SDK como variable de entorno mediante un archivo `.env`, o directamente en la configuración de tu aplicación, según prefieras.

**`.env`**

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

Concede a la clave el permiso **Imagen y vídeo**.

#### Instala el SDK

#### SDK

También usaremos la biblioteca `dotenv` para cargar nuestra clave de API desde una variable de entorno.

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

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

#### CLI

Instala la CLI de ElevenLabs. Recomendamos Homebrew (macOS) y 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**
>
> ¿Trabajas con un asistente de programación con IA? Ejecuta `elevenlabs generate-skills` en tu proyecto para crear un
> `SKILL.md` para cada grupo de comandos en `skills/`, para que tu asistente conozca todas las funciones de la CLI
> sin que tengas que pegar la documentación. Usa `--output-dir` para guardarlos en otro lugar. Esto lee la definición de la API
> integrada en la propia CLI, por lo que no necesita una clave de API y funciona sin conexión; además, se mantiene al día con
> la versión de la CLI que tengas instalada.

Después, autentícate; se abrirá el navegador para autorizar la CLI:

```bash
elevenlabs auth login
```

#### Consigue una foto

Descarga la foto de ejemplo en la carpeta donde crearás tu script:

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

## Encuentra el código de la plantilla

Abre [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy) en la app de ElevenLabs y selecciona la pestaña **API**. Todas las plantillas tienen una, con el código para ejecutarlas en cURL, Python y TypeScript.

![Pestaña API de la plantilla](/docs/_fern-img/801c9d2e2736964b35f5bad954092c973b21eedc03801128f1ed8bf31ea095b1.webp)

La pestaña muestra tres pasos: obtener una clave de API, elegir cómo obtener el resultado y ejecutar la plantilla. En **Elige cómo obtener el resultado**, está seleccionado **Esperar al resultado** de forma predeterminada. El código del tercer paso se abre en cURL; selecciona **Python** o **TypeScript**, y el paso pasará a ser **Ejecutar y esperar al resultado**. Su fragmento inicia una ejecución, espera a que termine e imprime cada salida. Pasa un valor en `inputs` por cada entrada de la plantilla, usando como clave el id de la entrada, y lee cada resultado de `outputs` mediante el id de la salida. Esta plantilla tiene una entrada, `garment_photo`, y una salida, `packshot`. Estos dos id son los únicos nombres que necesita tu código.

## Ejecuta la plantilla

Crea `packshot.py` o `packshot.mts`. Es el fragmento de la pestaña API con estos cambios:

* La clave de API se carga desde tu archivo `.env`.
* La foto se pasa como base64 en lugar de `YOUR_ASSET_ID`, el ID de un archivo ya subido a ElevenLabs.
* El script imprime una línea mientras la ejecución está en curso y guarda la imagen de producto en `packshot.jpg` en lugar de imprimir su 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) inicia la ejecución y, después, la consulta en el intervalo que sugiere la API hasta que todas las salidas hayan terminado. Una ejecución que falla se devuelve, no genera una excepción, por lo que el script comprueba el `status` de la salida antes de leerla. `version_id` fija la versión de la plantilla con la que se escribió este tutorial, para que una edición posterior de la plantilla no pueda romper el script.

Ejecuta el script. Una ejecución de esta plantilla usa unos 1020 créditos, lo mismo que al ejecutarla en la app.

```python
python packshot.py
```

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

Tras entre 30 segundos y un minuto, el script imprime:

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

Abre `packshot.jpg`. La prenda de la foto ahora está sobre un maniquí con un fondo de estudio liso; la cama y la iluminación han desaparecido.

> **Note**
>
> `create_and_wait` es para scripts y para probar plantillas. En producción, recibe las ejecuciones
> terminadas mediante un [webhook](/docs/es/eleven-api/guides/how-to/image-and-video/webhooks), para que tu
> aplicación no mantenga una solicitud abierta mientras una ejecución está en curso. [Ejecuta la plantilla de tu equipo](/docs/es/eleven-api/guides/how-to/templates/run-a-template) te muestra cómo hacerlo.

## Ejecútala con tu propia foto

Haz una foto con el móvil de cualquier prenda de ropa. No tiene que ser una buena foto: sirve una camiseta sobre la cama o una chaqueta en una silla. Guárdala como un JPEG sobre `garment.jpg` y vuelve a ejecutar el script.

Obtendrás una imagen de producto de tu prenda con el mismo aspecto de estudio, porque cada ejecución de una plantilla pasa por los mismos modelos y ajustes. Los detalles pueden variar de una ejecución a otra, incluso con la misma foto.

## Lo que has aprendido

* Una plantilla recibe **entradas** con nombre y genera **salidas** con nombre, y su pestaña **API** muestra el código para ejecutarla.
* `flows.templates.runs.create_and_wait` inicia una **ejecución** con un valor por cada id de entrada y devuelve el resultado cuando termina. Lees cada salida por su id y compruebas su `status`.
* En producción, un **webhook** entrega cada ejecución terminada, de modo que nada tiene que esperarla.

## Siguientes pasos

#### [Ejecuta la plantilla de tu equipo](/docs/es/eleven-api/guides/how-to/templates/run-a-template)

Copia el código de una plantilla desde su pestaña API, rellena cada tipo de entrada, recibe el resultado mediante
webhook y fija una versión.

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

Configura un webhook de producción, verifica las firmas manualmente y gestiona reintentos y eventos duplicados.

#### [Crea una plantilla](/docs/es/eleven-creative/products/flows#creating-a-template)

Cómo tu equipo convierte un Flujo en una plantilla: elegir sus entradas y salidas, y compartirla.

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

Todos los parámetros de una ejecución de plantilla.