🎉 Gerações grátis na primeira compra de cada pacote — até 20 vídeos Lite + 20 imagens Lite + 10 vídeos Medium + 10 imagens Pro + 2 vídeos Pro.

Começar
DreamUtopia
pt

Claude Code agora pode gerar vídeos

O Claude Code já funciona no seu terminal. Com a API REST do DreamUtopia, a mesma sessão pode transformar uma foto de produto em um clipe curto, animar um retrato ou encadear uma imagem finalizada em um vídeo de primeiro quadro. Cole um arquivo de skill, peça em inglês simples, e o agente cuida do upload, da requisição e do polling. Você continua trabalhando na mesma conversa enquanto a renderização é executada nos nossos servidores.

Comece com um exemplo real

Estes são os prompts usados nos exemplos desta página. Abra o gerador, escolha um exemplo e ajuste um detalhe de cada vez.

Uma estrada costeira na hora dourada, a câmera avançando suavemente enquanto o oceano cintila abaixo dos penhascos.

Prompt de exemplo 01

Uma estrada costeira na hora dourada, a câmera avançando suavemente enquanto o oceano cintila abaixo dos penhascos.

Um balão de ar quente à deriva sobre vinhedos enevoados ao nascer do sol, seu reflexo movendo-se pelo rio abaixo.

Prompt de exemplo 02

Um balão de ar quente à deriva sobre vinhedos enevoados ao nascer do sol, seu reflexo movendo-se pelo rio abaixo.

Um festival de lanternas de papel ao crepúsculo, com as lanternas subindo enquanto a câmera se inclina para cima em direção ao céu cálido.

Prompt de exemplo 03

Um festival de lanternas de papel ao crepúsculo, com as lanternas subindo enquanto a câmera se inclina para cima em direção ao céu cálido.

Geração de Vídeo com Claude Code, Sem Sair do Terminal

A geração de vídeo no Claude Code torna-se uma parte normal de uma sessão de programação quando o agente consegue chamar diretamente uma API de media. Os agentes de programação são bons a executar comandos, a ler respostas JSON e a tentar novamente com critério, que é exatamente o que uma API de imagem-para-vídeo precisa. Em vez de sair do terminal para abrir uma aplicação web, pode pedir ao Claude Code para transformar ./photo.png num clipe de cinco segundos em 720p e receber de volta um URL de resultado assinado na mesma conversa. Construímos a API DreamUtopia como REST simples por esta razão. Não há servidor MCP para configurar nem plugin para instalar. Um único ficheiro de skill ensina ao agente o URL base, o cabeçalho de autenticação, o upload multipart para imagens de referência, o endpoint de criação de vídeo, o endpoint de job partilhado e as regras de estado terminal. Uma skill colada e uma variável de ambiente são toda a configuração. A mesma chave também funciona a partir dos seus próprios scripts, para que o agente e o seu pipeline de build partilhem uma integração e um saldo de créditos. Um job de vídeo é mais lento do que um job de imagem, normalmente entre um e três minutos, por isso o ciclo de polling importa. A skill diz ao agente para esperar com backoff, para parar numa falha terminal e nunca tentar novamente uma recusa por política de conteúdo ou um saldo vazio. Também distingue um job que ainda está em fila de um que deixou de fazer progressos. Essa distinção é a diferença entre uma espera calma e uma tempestade de tentativas. Um ciclo de polling que tenta novamente indiscriminadamente pode consumir a allowance antes de a primeira renderização terminar, enquanto um ciclo que para demasiado cedo abandona um job que ainda estava a progredir. Para um repositório que entrega media ao lado do código, o ganho prático é que a pessoa que escreve o componente também pode produzir o clipe de que precisa, sem perder o contexto da alteração ou copiar ficheiros entre ferramentas. O agente pode explicar uma renderização falhada com a mesma voz que usa para um teste falhado, e pode manter o resultado junto ao código que o referencia.

O Que Você Recebe

Uma habilidade de copiar e colar

Cole o bloco de habilidades abaixo no chat do Claude Code. O agente segue a receita pelo restante da conversa sem prompts adicionais. O texto é curto o suficiente para ser lido de uma só vez e específico o suficiente para que o agente não improvise nomes de campos. Ele declara os valores exatos que cada campo aceita, de modo que uma solicitação malformada é corrigida antes de chegar à API. Nada é escrito no seu repositório e nada é instalado.

Fotos locais tratadas

Peça ao agente para usar um arquivo no projeto. Ele envia um upload multipart, recebe um id de upload e usa esse id como primeiro frame. JPEG, PNG e WebP são aceitos até 30 MB. Um arquivo no repositório nunca precisa primeiro de uma URL pública, o que mantém fotos privadas de produtos fora de uma etapa separada de hospedagem.

Todos os formatos de vídeo

Transições de imagem para vídeo, texto para vídeo e primeiro e último quadro compartilham uma única chave. Escolha 480p, 720p ou 1080p e uma duração de cinco a quinze segundos. O nível Lite tem limite de 720p e dez segundos; Medium e Pro alcançam 1080p e quinze segundos. A skill lê esses limites da lista de modelos ativa em vez de adivinhar.

Empregos que sobrevivem ao chat

Cada renderização é executada nos nossos servidores. Se a sessão terminar, o agente pode listar os trabalhos recentes por id e recolher o resultado mais tarde. O link assinado permanece válido durante sete dias, tempo suficiente para descarregar o ficheiro ou copiá-lo para um artefacto de compilação. Um trabalho falhado mantém o seu código de erro, para que a sessão seguinte possa explicar o que aconteceu. Recolher o resultado mais tarde também é mais seguro do que manter um terminal aberto durante vários minutos enquanto a renderização é concluída, especialmente numa máquina remota ou numa ligação intermitente.

Movimento em inglês simples

Descreva o plano, não a API: um avanço lento, um deslize para a direita, cabelo movendo-se ao vento. A habilidade mapeia suas palavras para o tier do modelo, resolução, duração e proporção, depois verifica a matriz de preços em tempo real antes de gastar. Você ainda pode nomear configurações exatas quando uma tarefa precisar delas, e o agente informa as configurações que escolheu para que um resultado inesperado seja mais fácil de diagnosticar. Uma solicitação ambígua é resolvida com uma pergunta de esclarecimento em vez de uma renderização especulativa que gasta créditos na duração errada.

Uma lista de preços

A API e o aplicativo web cobram os mesmos créditos. GET /v1/models retorna a matriz ativa de resolução, duração e créditos, para que o agente possa comparar um clipe de cinco segundos com um de dez segundos antes de criar qualquer coisa. Os créditos são cobrados quando a tarefa é criada e devolvidos automaticamente se ela falhar.

Como Funciona

1

Crie e exporte a chave

Abra o Perfil, depois Chaves de API, e crie uma chave nomeada. Exporte-a como DREAMUTOPIA_API_KEY no shell que inicia o Claude Code. As chaves estão disponíveis para contas pagas, são exibidas uma única vez e podem ser revogadas sem afetar suas outras integrações.

2

Cole a habilidade

Copie o bloco abaixo e cole-o no chat do Claude Code. O agente então conhece os endpoints, os nomes dos campos e as regras de polling para essa conversa. A skill também declara o que não fazer: não repetir um trabalho recusado e não colar a chave na conversa. Repita a colagem em uma nova sessão; nada é adicionado ao seu repositório.

3

Peça um clipe

Escreva uma solicitação normal: transforme ./photo.png em um clipe de oito segundos em 720p com um push-in lento. O agente escolhe as configurações, pode verificar /v1/models primeiro e lida com o upload quando a origem é um arquivo local. Se a solicitação for ambígua, ele faz uma pergunta curta em vez de adivinhar uma duração ou uma proporção de aspecto.

4

Enquete e use o resultado

O agente consulta GET /v1/generations/{id} até que a tarefa seja concluída com sucesso e, em seguida, retorna a URL assinada do resultado. Ele aplica backoff entre as consultas e para em caso de falha terminal, em vez de tentar novamente uma recusa por política de conteúdo ou um saldo esgotado. A resposta final inclui o id da tarefa, bem como o link, para que o resultado possa ser encontrado novamente depois que a conversa não estiver mais disponível.

Cole o DreamUtopia Skill no Claude Code

Copie a skill abaixo e cole-a no chat do Claude Code. O agente então conhece a superfície da API, os limites de vídeo, as regras de erro e quando não tentar novamente pelo resto da conversa.

Paste into Claude Code
Download
> Paste this into the Claude Code chat. It teaches the agent the DreamUtopia API for the
> rest of the conversation. Keep the `DREAMUTOPIA_API_KEY` in your shell environment,
> not in the pasted text.

# DreamUtopia media generation

Use this skill when the user asks you to generate an image or a video with DreamUtopia.

## Prerequisites

- **API access requires a paid account.** Keys cannot be minted by a free account.
- The user sets their key in the environment:

  ```sh
  export DREAMUTOPIA_API_KEY="du_live_..."
  ```

  If `DREAMUTOPIA_API_KEY` is unset, **stop and ask the user to set it**. Never write the key
  into a project file, a commit, or a message.
- Base URL: `https://api.dreamutopia.net/v1`
- Every request sends `Authorization: Bearer $DREAMUTOPIA_API_KEY`.

## Keeping this skill current

This skill is served by the product and can change without notice. If a request fails in a way
this document does not describe — an unknown field, an unexpected status or error code, or a
route that returns `404` — the skill may be stale. Re-fetch it, paste the new version into the
conversation, and re-read it before retrying:

```sh
curl -fsSL https://dreamutopia.net/skills/dreamutopia/claude-code.md
```

Do not invent request fields from memory. The re-fetched file is the current contract; the copy
in the conversation is only a snapshot.

## 1. Upload a local reference image (optional)

Only needed when the user has a local file. A previous generation's `result.url` can be used
directly instead.

```sh
curl -sS -X POST https://api.dreamutopia.net/v1/uploads \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY" \
  -F "file=@/path/to/photo.png"
```

Response `201`:

```json
{ "id": "<upload_id>",
  "url": "<upload_url>",
  "expires_at": "2026-10-31T12:00:00Z" }
```

Use `id` (not `url`) in the next request. Accepted: JPEG, PNG, WebP, up to 30 MB.
`id` only works for the account that uploaded it.

## 2. Create an image

```sh
curl -sS -X POST https://api.dreamutopia.net/v1/images/generations \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lite",
    "prompt": "a red fox in fresh snow, cinematic",
    "resolution": "2k",
    "aspect_ratio": "1:1"
  }'
```

| Field | Values |
|---|---|
| `model` | `lite`, `pro` |
| `resolution` | `2k`, `4k` (`lite` accepts `2k` only) |
| `aspect_ratio` | `1:1`, `4:3`, `3:4`, `16:9`, `9:16`, `3:2`, `2:3`, `adaptive` |
| `reference_images` | array of upload ids or DreamUtopia URLs; 0–3 for `lite`, 0–14 for `pro` |
| `prompt` | non-empty, up to 8000 characters |

`adaptive` requires at least one reference image. `resolution` defaults to `2k` and
`aspect_ratio` to `1:1`.

Response `202`:

```json
{ "id": "3f2b…", "type": "image", "status": "queued", "created_at": "2026-10-24T12:00:00Z" }
```

## 3. Create a video

```sh
curl -sS -X POST https://api.dreamutopia.net/v1/videos/generations \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "medium",
    "prompt": "the fox turns and looks at the camera",
    "image": "<upload_id>",
    "resolution": "720p",
    "duration": 8
  }'
```

| Field | Values |
|---|---|
| `model` | `lite`, `medium`, `pro` |
| `resolution` | `480p`, `720p`, `1080p` (`lite` cannot use `1080p`) |
| `duration` | 5–10 seconds (`lite`), 5–15 (`medium`), 5–30 (`pro`) |
| `image` | first-frame upload id or DreamUtopia URL (omit for text-to-video) |
| `last_frame_image` | requires `image`; not supported by `lite` |
| `generate_audio` | `pro` only, and the account must hold premium; `lite` and `medium` are rejected |

Response `202` with `type: "video"`.

## 4. Poll until it finishes

```sh
curl -sS https://api.dreamutopia.net/v1/generations/$MID \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY"
```

`status` is one of `queued`, `processing`, `succeeded`, `failed`.

- Poll every 3–5 seconds, backing off to 10 seconds. Give up after about 10 minutes.
- On `succeeded`, download `result.url`. The link is valid for 7 days.
- On `failed`, report `error.message` to the user and stop. A failed job is terminal; do
  **not** submit it again automatically.
- If an id is lost, `GET /generations?limit=20` lists recent jobs, newest first.

Terminal response:

```json
{
  "id": "3f2b…",
  "type": "video",
  "status": "succeeded",
  "model": "medium",
  "credits_used": 12,
  "created_at": "2026-10-24T12:00:00Z",
  "updated_at": "2026-10-24T12:02:10Z",
  "result": { "url": "<result_url>" },
  "error": null
}
```

## 5. Check credits and prices

```sh
curl -sS https://api.dreamutopia.net/v1/account -H "Authorization: Bearer $DREAMUTOPIA_API_KEY"
curl -sS https://api.dreamutopia.net/v1/models
```

`/models` is public and returns every tier's allowed resolutions and durations plus the
`resolution → duration → credits` matrix. Check it before choosing settings when the user
cares about cost.

## Errors

Every error body is exactly:

```json
{ "error": { "code": "insufficient_credits", "message": "You need more credits to generate." } }
```

| HTTP | Meaning |
|---|---|
| 400 | invalid input (`invalid_request`, `prompt_too_long`, `invalid_reference_image`, …) |
| 401 | missing, malformed, revoked or removed-account key |
| 402 | not enough credits |
| 403 | unpaid key creation, or audio requested without premium |
| 404 | unknown job, or a job belonging to another account |
| 409 | `Idempotency-Key` reused with a different body, or still in flight |
| 413 / 415 | upload too large / not a supported image |
| 429 | rate limited; read `Retry-After` |
| 500 / 503 | internal; retry later |

Retry only HTTP `429`, `timeout` and `internal` responses. Never retry
`insufficient_credits`, and never resubmit a job that already finished as `failed`.

## Idempotency

Send `Idempotency-Key: <unique value>` on a create request. A retry with the same key and
body returns the existing job (`200`) instead of creating and charging a second one. Use a
fresh value for every genuinely different request.

## Complete example

```sh
#!/usr/bin/env bash
set -euo pipefail
: "${DREAMUTOPIA_API_KEY:?set DREAMUTOPIA_API_KEY first}"
API="https://api.dreamutopia.net/v1"

ID=$(curl -sS -X POST "$API/images/generations" \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"lite","prompt":"a red fox in fresh snow","resolution":"2k","aspect_ratio":"1:1"}' \
  | jq -r .id)

while :; do
  BODY=$(curl -sS "$API/generations/$ID" -H "Authorization: Bearer $DREAMUTOPIA_API_KEY")
  STATUS=$(jq -r .status <<<"$BODY")
  case "$STATUS" in
    succeeded) jq -r .result.url <<<"$BODY"; break ;;
    failed)    jq -r .error.message <<<"$BODY" >&2; exit 1 ;;
    *)         sleep 4 ;;
  esac
done
```

Explore ferramentas relacionadas

Escolha a ferramenta que combina com seu próximo passo.

Perguntas Frequentes

Pela Equipe DreamUtopia · Última atualização em 15 de novembro de 2026

Preciso de um servidor MCP para gerar vídeo a partir do Claude Code?

▼
Não. A API é HTTP simples, e a skill ensina o Claude Code a chamá-la com curl. Você não precisa de um servidor MCP, um binário de CLI ou um plugin. A única configuração é colar a skill e a variável de ambiente.

Onde a chave da API deve ficar?

▼
No ambiente de shell como DREAMUTOPIA_API_KEY. Mantenha-a fora da skill colada, do repositório e do prompt. A skill instrui o agente a parar e perguntar se a variável estiver ausente, o que evita uma requisição semiconfigurada.

O agente pode enviar uma foto local como primeiro quadro?

▼
Sim. Peça-lhe para usar um ficheiro no projeto. O agente envia um upload multipart, recebe um id de upload e passa esse id ao pedido de vídeo. JPEG, PNG e WebP são aceites até 30 MB, o que cobre a maioria das imagens de câmara e de produto.

Qual é a duração máxima de um clipe gerado?

▼
De cinco a quinze segundos, dependendo do nível. O nível Lite para aos dez segundos; Medium e Pro chegam a quinze. A skill lê o limite máximo de GET /v1/models antes de enviar a solicitação, então uma duração excessiva é corrigida em vez de rejeitada.

Quais resoluções estão disponíveis?

▼
480p, 720p e 1080p. O nível Lite tem limite de 720p, enquanto Medium e Pro renderizam em 1080p. A proporção de aspeto é adaptativa por predefinição, e o agente pode escolher um enquadramento vertical, quadrado ou horizontal quando o destino é conhecido.

Como os créditos são cobrados por um vídeo?

▼
Os créditos são cobrados quando a tarefa é criada e devolvidos automaticamente se ela falhar. A matriz de preços atualizada está em GET /v1/models, e a skill a consulta quando você pergunta sobre o custo. É necessária uma conta paga antes que uma chave possa ser criada.

O que acontece se eu fechar a sessão?

▼
A tarefa continua em execução nos nossos servidores. Use GET /v1/generations/{id} com o id, ou liste as tarefas recentes com GET /v1/generations?limit=20. O URL do resultado assinado permanece válido por sete dias, portanto não há pressa para o recolher.

Dê ao Claude Code uma ferramenta de vídeo

Crie uma chave, cole a skill e peça seu primeiro clipe. A documentação da API cobre cada campo, status e código de erro.