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

# Início rápido de templates

Neste tutorial, você executará um template público usando um script em Python ou TypeScript. O template transforma uma foto casual de celular de uma peça de roupa em uma foto limpa de produto, e o script salva o resultado ao lado dela. O tutorial leva cerca de cinco minutos, e a execução em si leva menos de um minuto.

![Foto de celular e foto de produto](/docs/_fern-img/6afed41d4d791df68c87f183bd8db1d4aca8b4be3e946cc518534bda902f9528.webp)

Um **template** é um [Fluxo do ElevenCreative](/docs/pt/eleven-creative/products/flows) publicado: uma cadeia de modelos que recebe um conjunto fixo de **entradas** e produz um conjunto fixo de **saídas**. O que você executará, [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy), recebe uma imagem e retorna uma imagem. O autor já escolheu os modelos e prompts, então seu código só envia a foto.

> **Warning**
>
> A execução de um template exige um plano Pro ou superior.

## Configuração

#### Crie uma chave de API

[Crie uma chave de API no painel aqui](https://elevenlabs.io/app/settings/api-keys), que você usará para [acessar a API](/docs/pt/api-reference/authentication) com segurança.

Armazene a chave como um segredo gerenciado e passe-a aos SDKs como uma variável de ambiente por meio de um arquivo `.env` ou diretamente na configuração do seu app, conforme sua preferência.

**`.env`**

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

Dê à chave a permissão **Image & Video**.

#### Instale o SDK

#### SDK

Também usaremos a biblioteca `dotenv` para carregar nossa chave de API de uma variável de ambiente.

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

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

#### CLI

Instale a CLI da ElevenLabs. Recomendamos 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**
>
> Está trabalhando com um assistente de programação com IA? Execute `elevenlabs generate-skills` no seu projeto para criar um
> `SKILL.md` para cada grupo de comandos em `skills/`, para que seu assistente conheça toda a superfície da CLI
> sem que você precise colar a documentação. Use `--output-dir` para colocá-los em outro lugar. Isso lê a própria
> definição de API incorporada da CLI, portanto não precisa de chave de API e funciona off-line — além de acompanhar
> a versão da CLI que você tiver instalado.

Em seguida, autentique-se — isso abrirá seu navegador para autorizar a CLI:

```bash
elevenlabs auth login
```

#### Obtenha uma foto

Baixe a foto de exemplo para a pasta onde você criará seu script:

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

## Encontre o código do template

Abra [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy) no app da ElevenLabs e selecione a aba **API**. Todo template tem uma, com o código para executá-lo em cURL, Python e TypeScript.

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

A aba orienta você em três etapas: obter uma chave de API, escolher como receber o resultado e executar o template. Em **Escolha como receber o resultado**, **Aguarde o resultado** está selecionado por padrão. O código da terceira etapa abre em cURL; selecione **Python** ou **TypeScript**, e a etapa passará a ser **Execute e aguarde o resultado**. Seu trecho inicia uma execução, espera ela terminar e imprime cada saída. Ele passa um valor em `inputs` para cada entrada do template, usando o id da entrada como chave, e lê cada resultado em `outputs` pelo id da saída. Este template tem uma entrada, `garment_photo`, e uma saída, `packshot`. Esses dois ids são os únicos nomes de que seu código precisa.

## Execute o template

Crie `packshot.py` ou `packshot.mts`. É o trecho da aba API com estas alterações:

* A chave de API é carregada do seu arquivo `.env`.
* A foto é passada como base64 no lugar de `YOUR_ASSET_ID`, o ID de um arquivo já enviado para a ElevenLabs.
* O script imprime uma linha enquanto a execução está em andamento e salva a foto de produto em `packshot.jpg`, em vez de imprimir sua 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` em TypeScript) inicia a execução e depois a verifica no intervalo sugerido pela API até que todas as saídas sejam concluídas. Uma execução que falha é retornada, não lançada, então o script verifica o `status` da saída antes de lê-la. `version_id` fixa a versão do template usada neste tutorial, para que uma edição posterior do template não interrompa o script.

Execute o script. Uma execução deste template usa cerca de 1.020 créditos, o mesmo que executá-lo no app.

```python
python packshot.py
```

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

Após 30 segundos a um minuto, o script imprime:

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

Abra `packshot.jpg`. A peça de roupa da foto agora está em um manequim, contra um fundo liso de estúdio, sem a cama e a iluminação original.

> **Note**
>
> `create_and_wait` é para scripts e para testar templates. Em produção, receba as execuções concluídas
> por um [webhook](/docs/pt/eleven-api/guides/how-to/image-and-video/webhooks), para que seu
> aplicativo não mantenha uma solicitação aberta enquanto uma execução estiver em andamento. [Execute o template da sua equipe](/docs/pt/eleven-api/guides/how-to/templates/run-a-template) mostra como.

## Execute com sua própria foto

Tire uma foto de qualquer peça de roupa com seu celular. Não precisa ser uma boa foto: uma camiseta na sua cama ou uma jaqueta sobre uma cadeira serve. Salve-a como JPEG em `garment.jpg` e execute o script novamente.

Você receberá uma foto de produto da sua peça com o mesmo visual de estúdio, pois cada execução de um template passa pelos mesmos modelos e configurações. Os detalhes ainda podem variar entre execuções, mesmo com a mesma foto.

## O que você aprendeu

* Um template recebe **entradas** nomeadas e produz **saídas** nomeadas, e sua aba **API** mostra o código que o executa.
* `flows.templates.runs.create_and_wait` inicia uma **execução** com um valor por id de entrada e retorna quando ela termina. Você lê cada saída pelo id e verifica seu `status`.
* Em produção, um **webhook** entrega cada execução concluída, sem que nada precise esperar por ela.

## Próximas etapas

#### [Execute o template da sua equipe](/docs/pt/eleven-api/guides/how-to/templates/run-a-template)

Copie o código de um template na aba API, preencha cada tipo de entrada, receba o resultado por
webhook e fixe uma versão.

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

Configure um webhook de produção, verifique assinaturas manualmente e lide com novas tentativas e eventos duplicados.

#### [Crie um template](/docs/pt/eleven-creative/products/flows#creating-a-template)

Veja como sua equipe transforma um Fluxo em template: escolhendo suas entradas e saídas e compartilhando-o.

#### [Referência da API](/docs/pt/api-reference/flows/templates/runs/create)

Todos os parâmetros de uma execução de template.