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

# Creare un video xAI

> Usa CometAPI POST /grok/v1/videos/generations per creare job Grok da immagine a video a partire da un'immagine di input e un prompt, quindi interroga i risultati tramite request_id.

Usa questo endpoint per avviare un job Grok da immagine a video a partire da un'immagine sorgente e un prompt. Restituisce immediatamente un `request_id`, quindi trattalo come il primo passaggio di un flusso di lavoro asincrono.

## Inizia con una richiesta piccola

* Usa `model: grok-imagine-video-1.5`
* Imposta `image.url` su un URL pubblico JPEG, PNG o WebP
* Per una prima richiesta, mantieni `duration` a `1` e `resolution` a `720p`
* Mantieni `prompt` esplicito in modo che la direzione dell'animazione sia chiara
* Se invii base64, mantieni nei documenti e nell'esempio OpenAPI il formato `data:image/png;base64,<BASE64_IMAGE_DATA>`

## Durata e risoluzione

| Impostazione   | Valori supportati                                 | Predefinito         | Comportamento ai limiti                                                                                                     |
| -------------- | ------------------------------------------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `duration`     | intero `1`-`15`                                   | `8`                 | Usa clip più brevi per i primi test; le clip più lunghe costano di più e richiedono più tempo per essere completate.        |
| `resolution`   | `480p`, `720p`, `1080p`                           | `720p` negli esempi | Le richieste con risoluzione più alta costano di più e richiedono più tempo per essere completate.                          |
| `aspect_ratio` | etichette di rapporto come `1:1`, `16:9` o `9:16` | `16:9` negli esempi | Questo endpoint usa `resolution` più `aspect_ratio`; non inviare un campo `size` separato per un controllo esatto di `WxH`. |

| Combinazione della richiesta             | Output previsto `WxH` |
| ---------------------------------------- | --------------------- |
| `resolution: 480p`, `aspect_ratio: 1:1`  | `480x480`             |
| `resolution: 720p`, `aspect_ratio: 16:9` | `1280x720`            |
| `resolution: 720p`, `aspect_ratio: 9:16` | `720x1280`            |

## Flusso dell'attività

<Steps>
  <Step title="Create the job">
    Invia il prompt e l'immagine sorgente, quindi salva il `request_id` restituito.
  </Step>

  <Step title="Poll for completion">
    Chiama [Get xAI video results](./get-video-generation-results) finché lo stato annidato del provider non diventa `done`.
  </Step>

  <Step title="Persist the output">
    Copia il `video.url` finale nel tuo sistema di archiviazione se ti serve dopo la finestra di distribuzione temporanea del provider.
  </Step>
</Steps>


## OpenAPI

````yaml api/openapi/video/xai/post-video-generation.openapi.json POST /grok/v1/videos/generations
openapi: 3.1.0
info:
  title: Video Generation API
  version: 1.0.0
  description: >-
    Create an asynchronous xAI Grok image-to-video job and poll it later with
    GET /grok/v1/videos/{request_id}.
servers:
  - url: https://api.cometapi.com
security:
  - bearerAuth: []
paths:
  /grok/v1/videos/generations:
    post:
      summary: Create an xAI video generation job
      description: >-
        Start a Grok image-to-video job from a prompt and one source image. Save
        the returned request_id and poll the query endpoint until the provider
        status becomes done.
      operationId: video_generation
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - prompt
              properties:
                prompt:
                  type: string
                  description: >-
                    Prompt describing how the source image should animate.
                    CometAPI requires this field for this route.
                  example: >-
                    Animate the still image with a slow camera move and natural
                    motion.
                aspect_ratio:
                  type: string
                  description: >-
                    Output aspect ratio. Combine with resolution to choose the
                    target frame; for example 480p with 1:1 targets 480x480,
                    720p with 16:9 targets 1280x720, and 720p with 9:16 targets
                    720x1280. This endpoint does not expose an exact size field.
                  enum:
                    - '1:1'
                    - '16:9'
                    - '9:16'
                    - '4:3'
                    - '3:4'
                    - '3:2'
                    - '2:3'
                duration:
                  type: integer
                  description: >-
                    Output duration in seconds. Use an integer from 1 through
                    15. If omitted, CometAPI treats the request as an 8-second
                    generation for billing and default handling.
                  default: 8
                image:
                  type: object
                  required:
                    - url
                  properties:
                    url:
                      type: string
                      description: >-
                        Public image URL or data URI such as
                        data:image/png;base64,<BASE64_IMAGE_DATA>.
                  description: >-
                    Source image for image-to-video. Use a public JPEG, PNG, or
                    WebP URL, or a data URI such as
                    data:image/png;base64,<BASE64_IMAGE_DATA>.
                model:
                  type: string
                  description: >-
                    xAI video model id. The default example uses Grok Imagine
                    1.5 for image-to-video.
                  default: grok-imagine-video-1.5
                  example: grok-imagine-video-1.5
                output:
                  type: object
                  properties:
                    upload_url:
                      type: string
                      description: >-
                        Optional signed URL for uploading the finished result to
                        your own storage.
                resolution:
                  type: string
                  description: >-
                    Output resolution. Use 720p for a small image-to-video test,
                    or 1080p when you need a higher resolution tier.
                  enum:
                    - 480p
                    - 720p
                    - 1080p
                  default: 720p
                size:
                  type: string
                  description: Deprecated size field. Prefer aspect_ratio and resolution.
                user:
                  type: string
                  description: Optional end-user identifier.
              default:
                model: grok-imagine-video-1.5
                prompt: >-
                  Animate the still image with a slow camera move and natural
                  motion.
                image:
                  url: https://your-image-host/source.jpg
                duration: 1
                aspect_ratio: '16:9'
                resolution: 720p
            examples:
              Image URL:
                summary: Image URL
                value:
                  model: grok-imagine-video-1.5
                  prompt: >-
                    Animate the still image with a slow camera move and natural
                    motion.
                  image:
                    url: https://your-image-host/source.jpg
                  duration: 1
                  aspect_ratio: '16:9'
                  resolution: 720p
              Data URI:
                summary: Data URI
                value:
                  model: grok-imagine-video-1.5
                  prompt: Animate the clouds drifting across the sky.
                  image:
                    url: data:image/png;base64,<BASE64_IMAGE_DATA>
                  duration: 1
                  aspect_ratio: '16:9'
                  resolution: 720p
      responses:
        '200':
          description: Request accepted.
          content:
            application/json:
              schema:
                type: object
                required:
                  - request_id
                properties:
                  request_id:
                    type: string
                    description: Deferred request id used for polling.
                example:
                  request_id: <request_id>
              example:
                request_id: <request_id>
      x-codeSamples:
        - lang: Shell
          label: Image URL
          source: |
            curl https://api.cometapi.com/grok/v1/videos/generations \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              -H "Content-Type: application/json" \
              -d '{
                "model": "grok-imagine-video-1.5",
                "prompt": "Animate the still image with a slow camera move and natural motion.",
                "image": {"url": "https://your-image-host/source.jpg"},
                "duration": 1,
                "aspect_ratio": "16:9",
                "resolution": "720p"
              }'
        - lang: Shell
          label: Data URI
          source: |
            IMAGE_B64=$(base64 < source.png | tr -d '\n')

            curl https://api.cometapi.com/grok/v1/videos/generations \
              -H "Authorization: Bearer $COMETAPI_KEY" \
              -H "Content-Type: application/json" \
              --data-binary @- <<EOF
            {
              "model": "grok-imagine-video-1.5",
              "prompt": "Animate the clouds drifting across the sky.",
              "image": {"url": "data:image/png;base64,${IMAGE_B64}"},
              "duration": 1,
              "aspect_ratio": "16:9",
              "resolution": "720p"
            }
            EOF
        - lang: Python
          label: Image URL
          source: |
            import os
            import requests

            response = requests.post(
                "https://api.cometapi.com/grok/v1/videos/generations",
                headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
                json={
                    "model": "grok-imagine-video-1.5",
                    "prompt": "Animate the still image with a slow camera move and natural motion.",
                    "image": {"url": "https://your-image-host/source.jpg"},
                    "duration": 1,
                    "aspect_ratio": "16:9",
                    "resolution": "720p",
                },
            )

            task = response.json()
            print(task["request_id"])  # poll GET /grok/v1/videos/{request_id}
        - lang: Python
          label: Data URI
          source: |
            import base64
            import os
            import requests

            with open("source.png", "rb") as f:
                image_b64 = base64.b64encode(f.read()).decode()

            response = requests.post(
                "https://api.cometapi.com/grok/v1/videos/generations",
                headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
                json={
                    "model": "grok-imagine-video-1.5",
                    "prompt": "Animate the clouds drifting across the sky.",
                    "image": {"url": "data:image/png;base64," + image_b64},
                    "duration": 1,
                    "aspect_ratio": "16:9",
                    "resolution": "720p",
                },
            )

            task = response.json()
            print(task["request_id"])
        - lang: JavaScript
          label: Image URL
          source: >
            const response = await
            fetch("https://api.cometapi.com/grok/v1/videos/generations", {
                method: "POST",
                headers: {
                    Authorization: `Bearer ${process.env.COMETAPI_KEY}`,
                    "Content-Type": "application/json",
                },
                body: JSON.stringify({
                    model: "grok-imagine-video-1.5",
                    prompt: "Animate the still image with a slow camera move and natural motion.",
                    image: { url: "https://your-image-host/source.jpg" },
                    duration: 1,
                    aspect_ratio: "16:9",
                    resolution: "720p",
                }),
            });


            const task = await response.json();

            console.log(task.request_id); // poll GET
            /grok/v1/videos/{request_id}
        - lang: JavaScript
          label: Data URI
          source: >
            import { readFile } from "node:fs/promises";


            const imageB64 = (await readFile("source.png")).toString("base64");


            const response = await
            fetch("https://api.cometapi.com/grok/v1/videos/generations", {
                method: "POST",
                headers: {
                    Authorization: `Bearer ${process.env.COMETAPI_KEY}`,
                    "Content-Type": "application/json",
                },
                body: JSON.stringify({
                    model: "grok-imagine-video-1.5",
                    prompt: "Animate the clouds drifting across the sky.",
                    image: { url: `data:image/png;base64,${imageB64}` },
                    duration: 1,
                    aspect_ratio: "16:9",
                    resolution: "720p",
                }),
            });


            const task = await response.json();

            console.log(task.request_id);
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: Bearer token authentication. Use your CometAPI key.

````