> ## 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.

# Sora 2 Official API

> Sora 2 VIP is APIPod's official-provider routing ID for Sora 2. Its public contract supports 4-, 8-, or 12-second clips and an optional first-frame image.



## OpenAPI

````yaml api-reference/openapi/sora-2--sora-2-vip.yaml POST /v1/videos/generations
openapi: 3.1.0
info:
  title: Sora 2 Official API API
  version: 1.0.0
  description: >-
    Sora 2 VIP is APIPod's official-provider routing ID for Sora 2. Its public
    contract supports 4-, 8-, or 12-second clips and an optional first-frame
    image. In APIPod, the public model ID is sora-2-vip. It supports
    text-to-video and 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:
        - Sora 2 Official API
      summary: Create Generation Task
      description: >-
        Sora 2 VIP is APIPod's official-provider routing ID for Sora 2. Its
        public contract supports 4-, 8-, or 12-second clips and an optional
        first-frame image. In APIPod, the public model ID is sora-2-vip. It
        supports text-to-video and image-to-video, accepts text and image
        inputs, and returns results through asynchronous video tasks.
      operationId: create-sora-2-sora-2-vip
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              title: Sora 2(VIP)
              properties:
                model:
                  type: string
                  title: Model ID
                  description: Public APIPod model ID.
                  const: sora-2-vip
                prompt:
                  type: string
                  title: Prompt
                  description: Describe the content of the video to be generated.
                  maxLength: 4000
                image_url:
                  type: string
                  title: Image Url
                  description: >-
                    URL of the image to use as the first frame. Please do not
                    upload real portrait images, as this will most likely result
                    in failure. The image format must be consistent with the
                    ratio, and only 1280×720 (16:9 landscape) and 720×1280 (9:16
                    portrait) are supported.
                duration:
                  type: integer
                  title: Duration
                  description: The video durations
                  enum:
                    - 8
                    - 12
                  default: 8
                aspect_ratio:
                  type: string
                  title: Aspect Ratio
                  description: This parameter defines the aspect ratio of the video.
                  enum:
                    - '9:16'
                    - '16:9'
                  default: '9:16'
              required:
                - model
                - prompt
            example:
              model: sora-2-vip
              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: 8
              aspect_ratio: '9:16'
      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": "sora-2-vip",
              "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": 8,
              "aspect_ratio": "9:16"
            }'
        - lang: Python
          label: Python
          source: |-
            import os
            import requests

            payload = {
              "model": "sora-2-vip",
              "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": 8,
              "aspect_ratio": "9:16"
            }

            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": "sora-2-vip",
              "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": 8,
              "aspect_ratio": "9:16"
            }`), &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": "sora-2-vip",
              "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": 8,
              "aspect_ratio": "9:16"
            });
                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": "sora-2-vip",
                "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": 8,
                "aspect_ratio": "9:16"
              }
              ),
            });


            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.

````