🎉 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

O OpenCode agora pode gerar vídeo

O OpenCode já funciona no seu terminal. Com a DreamUtopia REST API, a mesma sessão pode transformar a foto de um 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 roda 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 anoitecer, com as lanternas subindo enquanto a câmera se inclina para o céu quente.

Prompt de exemplo 03

Um festival de lanternas de papel ao anoitecer, com as lanternas subindo enquanto a câmera se inclina para o céu quente.

Geração de vídeo com OpenCode, sem sair do terminal

A geração de vídeo no OpenCode torna-se uma parte normal de uma sessão de programação quando o agente pode chamar uma API de mídia diretamente. Agentes de programação são bons em executar comandos, ler respostas JSON e tentar novamente com discernimento, que é exatamente do que uma API de imagem para vídeo precisa. Em vez de sair do terminal para abrir um aplicativo web, você pode pedir ao OpenCode para transformar ./photo.png em um clipe de cinco segundos em 720p e receber uma URL de resultado assinada de volta na mesma conversa. Construímos a API DreamUtopia como REST puro por esse motivo. Não há servidor MCP para configurar e nenhum plugin para instalar. Um arquivo de skill ensina ao agente a 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 compartilhado 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, então o agente e seu pipeline de build compartilham uma integração e um saldo de créditos. Um job de vídeo é mais lento que um job de imagem, geralmente entre um e três minutos, então o loop de polling importa. A skill instrui o agente a esperar com backoff, parar em uma falha terminal e nunca tentar novamente uma recusa por política de conteúdo ou um saldo vazio. Ela também distingue um job que ainda está na fila de um que parou de progredir. Essa distinção é a diferença entre uma espera tranquila e uma tempestade de retentativas. Um loop de polling que tenta novamente indiscriminadamente pode consumir a franquia antes que a primeira renderização termine, enquanto um loop que para cedo demais abandona um job que ainda estava progredindo. Para um repositório que entrega mídia junto com código, o ganho prático é que a pessoa que escreve o componente também pode produzir o clipe de que ele precisa, sem perder o contexto da mudança ou copiar arquivos entre ferramentas. O agente pode explicar uma renderização falha com a mesma voz que usa para um teste falho, e pode manter o resultado ao lado do código que o referencia.

O que você recebe

Uma habilidade de copiar e colar

Cole o bloco de habilidades abaixo no chat do OpenCode. O agente segue a receita pelo restante da conversa sem solicitações extras. 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 é gravado no seu repositório e nada é instalado.

Fotos locais processadas

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.

Cada formato de vídeo

Transições de imagem para vídeo, texto para vídeo e de 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 coletar o resultado mais tarde. O link assinado permanece válido por sete dias, tempo suficiente para baixar o arquivo ou copiá-lo para um artefato de build. Um trabalho com falha mantém seu código de erro, para que a próxima sessão possa explicar o que aconteceu. Coletar o resultado mais tarde também é mais seguro do que manter um terminal aberto por vários minutos enquanto a renderização é concluída, especialmente em uma máquina remota ou em uma conexão intermitente.

Movimento em inglês simples

Descreva o enquadramento, não a API: um slow push-in, um deslize para a direita, cabelo movendo-se ao vento. A skill mapeia suas palavras para tier de modelo, resolução, duração e proporção, e então verifica a matriz de preços ao vivo 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 um render especulativo que gasta créditos na duração errada.

Uma lista de preços

A API e a aplicação 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 Perfil, depois Chaves de API, e crie uma chave nomeada. Exporte-a como DREAMUTOPIA_API_KEY no shell que inicia o OpenCode. 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 OpenCode. O agente então conhece os endpoints, nomes de campos e regras de polling para essa conversa. A skill também indica 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: faça um clipe de cinco segundos em 1080p a partir de ./beach.jpg com a câmera deslizando para a direita. O agente escolhe as configurações, pode verificar /v1/models primeiro e cuida do upload quando a fonte é 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 tela.

4

Enquete e use o resultado

O agente consulta GET /v1/generations/{id} até que a tarefa seja concluída com êxito e, em seguida, retorna o URL do resultado assinado. Ele aplica um intervalo crescente entre as consultas e para em caso de falha terminal, em vez de tentar novamente após 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 OpenCode

Copie a skill abaixo e cole no chat do OpenCode. 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 OpenCode
Download
> Paste this into the OpenCode 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/opencode.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 OpenCode?

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

Onde a chave de 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 solicitação semiconfigurada.

O agente pode carregar uma foto local como primeiro quadro?

▼
Sim. Peça para usar um arquivo no projeto. O agente envia um upload multipart, recebe um id de upload e passa esse id para a solicitação de vídeo. JPEG, PNG e WebP são aceitos até 30 MB, o que cobre a maioria das imagens de câmera 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 aos quinze. A skill lê o limite máximo de GET /v1/models antes de enviar a solicitação, portanto uma duração excessiva é corrigida em vez de rejeitada.

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

▼
480p, 720p e 1080p. O tier Lite tem limite de 720p, enquanto Medium e Pro renderizam em 1080p. A proporção de tela é adaptável por padrão, e o agente pode escolher um enquadramento retrato, quadrado ou paisagem 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 em tempo real 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 durante sete dias, por isso não há pressa em recolhê-lo.

Dê ao OpenCode uma Ferramenta de Vídeo

Crie uma chave, cole a skill e peça seu primeiro clipe. A documentação da API cobre todos os campos, status e códigos de erro.