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

# Grok Imagine Video 1.5 Preview

> Grok Imagine 1.5 Preview is a preview route that requires one source image in xAI's Grok Imagine video family, intended for short clips with coherent motion and...



## OpenAPI

````yaml api-reference/openapi/grok-imagine-1-5--grok-imagine-1-5-preview.yaml POST /v1/videos/generations
openapi: 3.1.0
info:
  title: Grok Imagine Video 1.5 Preview API
  version: 1.0.0
  description: >-
    Grok Imagine 1.5 Preview is a preview route that requires one source image
    in xAI's Grok Imagine video family, intended for short clips with coherent
    motion and synchronized audio. In APIPod, the public model ID is
    grok-imagine-1.5-preview. It supports image-to-video, accepts text and image
    inputs, and returns results through asynchronous video tasks.
servers:
  - url: https://api.apipod.ai
    description: Production
security: []
paths:
  /v1/videos/generations:
    post:
      tags:
        - Grok Imagine Video 1.5 Preview
      summary: Create Generation Task
      description: >-
        Grok Imagine 1.5 Preview is a preview route that requires one source
        image in xAI's Grok Imagine video family, intended for short clips with
        coherent motion and synchronized audio. In APIPod, the public model ID
        is grok-imagine-1.5-preview. It supports image-to-video, accepts text
        and image inputs, and returns results through asynchronous video tasks.
      operationId: create-grok-imagine-1-5-grok-imagine-1-5-preview
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              title: Grok Imagine 1.5 Video Preview
              properties:
                model:
                  type: string
                  title: Model ID
                  description: Public APIPod model ID.
                  const: grok-imagine-1.5-preview
                prompt:
                  type: string
                  title: Prompt
                  maxLength: 4000
                image_url:
                  type: string
                  title: Image Url
                  default: ''
                duration:
                  type: integer
                  title: Duration
                  description: Output video length.
                  default: 10
                  minimum: 1
                  maximum: 15
                resolution:
                  type: string
                  title: Resolution
                  description: Output resolution. Currently only 720p is supported.
                  enum:
                    - 480p
                    - 720p
                  default: 720p
                aspect_ratio:
                  type: string
                  title: Aspect Ratio
                  description: Output video width height aspect ratio
                  enum:
                    - '1:1'
                    - '16:9'
                    - '9:16'
                  default: '16:9'
              required:
                - model
                - prompt
                - image_url
            example:
              model: grok-imagine-1.5-preview
              prompt: >-
                A cinematic tracking shot through a rain-soaked neon street,
                realistic motion, synchronized ambient sound.
              image_url: https://cdn.example.com/reference.jpg
              duration: 10
              resolution: 720p
              aspect_ratio: '16:9'
      responses:
        '200':
          description: Task accepted
          content:
            application/json:
              schema:
                type: object
                title: Task Submit Response
                description: Standard response for task submission
                properties:
                  code:
                    type: integer
                  data:
                    type: object
                    title: Task Submit Data
                    description: Data content for task submission
                    properties:
                      task_id:
                        type: string
                        description: generatation task id
                  message:
                    type: string
                required:
                  - code
                  - message
                  - data
              example:
                code: 200
                message: success
                data:
                  task_id: vid_task_01JEXAMPLE
      security:
        - bearerAuth: []
      x-codeSamples:
        - lang: Shell
          label: cURL
          source: |-
            curl https://api.apipod.ai/v1/videos/generations \
              -H "Authorization: Bearer $APIPOD_API_KEY" \
              -H "Content-Type: application/json" \
              -d '{
              "model": "grok-imagine-1.5-preview",
              "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
              "image_url": "https://cdn.example.com/reference.jpg",
              "duration": 10,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            }'
        - lang: Python
          label: Python
          source: |-
            import os
            import requests

            payload = {
              "model": "grok-imagine-1.5-preview",
              "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
              "image_url": "https://cdn.example.com/reference.jpg",
              "duration": 10,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            }

            response = requests.post(
                "https://api.apipod.ai/v1/videos/generations",
                headers={
                    "Authorization": f"Bearer {os.environ['APIPOD_API_KEY']}",
                    "Content-Type": "application/json",
                },
                json=payload,
                timeout=60,
            )
            response.raise_for_status()
            print(response.json())
        - lang: Go
          label: Go
          source: |-
            package main

            import (
                "bytes"
                "encoding/json"
                "fmt"
                "net/http"
                "os"
            )

            func main() {
                payload := map[string]any{}
                if err := json.Unmarshal([]byte(`{
              "model": "grok-imagine-1.5-preview",
              "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
              "image_url": "https://cdn.example.com/reference.jpg",
              "duration": 10,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            }`), &payload); err != nil {
                    panic(err)
                }
                body, err := json.Marshal(payload)
                if err != nil {
                    panic(err)
                }

                req, err := http.NewRequest(http.MethodPost, "https://api.apipod.ai/v1/videos/generations", bytes.NewReader(body))
                if err != nil {
                    panic(err)
                }
                req.Header.Set("Authorization", "Bearer "+os.Getenv("APIPOD_API_KEY"))
                req.Header.Set("Content-Type", "application/json")

                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                    panic(err)
                }
                defer resp.Body.Close()
                fmt.Println(resp.Status)
            }
        - lang: Rust
          label: Rust
          source: |-
            use reqwest::Client;
            use serde_json::json;
            use std::env;

            #[tokio::main]
            async fn main() -> Result<(), Box<dyn std::error::Error>> {
                let payload = json!({
              "model": "grok-imagine-1.5-preview",
              "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
              "image_url": "https://cdn.example.com/reference.jpg",
              "duration": 10,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            });
                let response = Client::new()
                    .post("https://api.apipod.ai/v1/videos/generations")
                    .bearer_auth(env::var("APIPOD_API_KEY")?)
                    .json(&payload)
                    .send()
                    .await?
                    .error_for_status()?;

                println!("{}", response.text().await?);
                Ok(())
            }
        - lang: JavaScript
          label: JavaScript
          source: >-
            const response = await
            fetch("https://api.apipod.ai/v1/videos/generations", {
              method: "POST",
              headers: {
                Authorization: `Bearer ${process.env.APIPOD_API_KEY}`,
                "Content-Type": "application/json",
              },
              body: JSON.stringify(
              {
                "model": "grok-imagine-1.5-preview",
                "prompt": "A cinematic tracking shot through a rain-soaked neon street, realistic motion, synchronized ambient sound.",
                "image_url": "https://cdn.example.com/reference.jpg",
                "duration": 10,
                "resolution": "720p",
                "aspect_ratio": "16:9"
              }
              ),
            });


            if (!response.ok) {
              throw new Error(`APIPod request failed: ${response.status} ${await response.text()}`);
            }


            console.log(await response.json());
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: APIPod API key
      description: Use your APIPod API key as a Bearer token in the Authorization header.

````