> ## Documentation Index
> Fetch the complete documentation index at: https://developers.meshapi.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Video Generation

> Submit video generation tasks, poll for completion, and list past generations.

Video generation is asynchronous — you submit a task and poll for its status until it completes.

## Generate a video

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    from meshapi import MeshAPI, VideoGenerationParams, VideoContentItem

    client = MeshAPI(base_url="https://api.meshapi.ai", token="rsk_...")

    resp = client.videos.generate(
        VideoGenerationParams(
            model="byteplus/dreamina-seedance-2-0",
            content=[VideoContentItem(type="text", text="A serene mountain lake at sunrise")],
        )
    )
    print(resp.id)      # task ID
    print(resp.status)  # initial status
    ```
  </Tab>

  <Tab title="Node.js">
    ```javascript theme={null}
    const resp = await client.videos.generate({
      model: "byteplus/dreamina-seedance-2-0",
      content: [{ type: "text", text: "A serene mountain lake at sunrise" }],
    });
    console.log(resp.id);     // task ID
    console.log(resp.status); // initial status
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    text := "A serene mountain lake at sunrise"
    resp, err := client.Videos.Generate(ctx, meshapi.VideoGenerationParams{
        Model: "byteplus/dreamina-seedance-2-0",
        Content: []meshapi.VideoContentItem{
            {Type: "text", Text: &text},
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("task_id=%s\n", resp.ID)
    ```
  </Tab>
</Tabs>

## Retrieve task status

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    task = client.videos.retrieve(resp.id)
    print(task.id)
    print(task.status)  # pending / running / succeeded / failed
    ```
  </Tab>

  <Tab title="Node.js">
    ```javascript theme={null}
    const task = await client.videos.retrieve(resp.id);
    console.log(task.id);
    console.log(task.status); // pending / running / succeeded / failed
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    task, err := client.Videos.Retrieve(ctx, resp.ID)
    fmt.Printf("status=%s\n", task.Status)
    ```
  </Tab>
</Tabs>

## Poll until complete

```python theme={null}
import time

while True:
    task = client.videos.retrieve(resp.id)
    if task.status == "succeeded":
        print("done:", task.id)
        break
    elif task.status == "failed":
        raise RuntimeError(f"video generation failed: {task.id}")
    time.sleep(5)
```

## List past generations

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    from meshapi import ListVideoGenerationsParams

    listing = client.videos.list(ListVideoGenerationsParams(limit=5))
    print(f"total={listing.total} items={len(listing.data)}")
    for item in listing.data:
        print(item.id, item.status)
    ```
  </Tab>

  <Tab title="Node.js">
    ```javascript theme={null}
    const listing = await client.videos.list({ limit: 5 });
    console.log(`total=${listing.total} items=${listing.data.length}`);
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    limit := 5
    listing, err := client.Videos.List(ctx, &meshapi.ListVideoGenerationsParams{
        Limit: &limit,
    })
    fmt.Printf("total=%d items=%d\n", listing.Total, len(listing.Data))
    ```
  </Tab>
</Tabs>

## Task statuses

| Status      | Meaning                      |
| ----------- | ---------------------------- |
| `pending`   | Task queued, not yet started |
| `running`   | Generation in progress       |
| `succeeded` | Generation complete          |
| `failed`    | Generation failed            |