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

# Generate a video

> Creates a video generation job from a text prompt. This is an asynchronous operation
that returns immediately with a job ID. Use the retrieve endpoint to check the status
and get the video URL when generation is complete.




## OpenAPI

````yaml /openapi/openapi.json post /v1/videos
openapi: 3.1.0
info:
  title: Bifrost API
  description: >
    Bifrost HTTP Transport API for AI model inference and gateway management.


    This API provides a unified interface for interacting with multiple AI
    providers

    including OpenAI, Anthropic, Bedrock, Gemini, and more through a single API,

    along with comprehensive management APIs for configuring and monitoring the
    gateway.


    ## API Structure


    ### Unified Inference API (`/v1/*`)

    The primary API using Bifrost's unified format. Model parameters use the
    format

    `provider/model` (e.g., `openai/gpt-4`, `anthropic/claude-3-opus`).


    ### Async Inference API (`/v1/async/*`)

    Submit inference requests for asynchronous execution. Returns a job ID
    immediately

    and allows polling for results. Supports all inference types except batches,
    files,

    and containers.


    ### Provider Integration APIs

    Native provider-format APIs for drop-in compatibility:

    - `/openai/*` - OpenAI-compatible API

    - `/anthropic/*` - Anthropic-compatible API

    - `/genai/*` - Google GenAI (Gemini) compatible API

    - `/bedrock/*` - AWS Bedrock compatible API

    - `/cohere/*` - Cohere compatible API


    ### Framework Integration APIs

    Multi-provider proxy endpoints for AI frameworks:

    - `/litellm/*` - LiteLLM proxy with all provider formats

    - `/langchain/*` - LangChain compatible endpoints

    - `/pydanticai/*` - PydanticAI compatible endpoints


    ### Management APIs (`/api/*`)

    APIs for managing and monitoring the Bifrost gateway:

    - `/api/config` - Configuration management

    - `/api/providers` - Provider and API key management

    - `/api/plugins` - Plugin management

    - `/api/governance/*` - Virtual keys, teams, customers, budgets, rate
    limits, routing rules, and pricing overrides

    - `/api/logs` - Log search and analytics

    - `/api/mcp/*` - MCP (Model Context Protocol) client management

    - `/api/session/*` - Authentication and session management

    - `/api/cache/*` - Cache management

    - `/health` - Health check endpoint


    ## Fallbacks

    Requests can include fallback models that will be tried if the primary model
    fails.
  version: 1.0.0
  contact:
    name: Contact Us
    url: https://getmaxim.ai/bifrost
  license:
    name: Apache 2.0
    url: https://opensource.org/licenses/Apache-2.0
servers:
  - url: '{baseUrl}'
    description: Your Bifrost instance
    variables:
      baseUrl:
        default: http://localhost:8080
        description: Base URL of your Bifrost instance (e.g. https://bifrost.mycompany.com)
security:
  - BearerAuth: []
  - BasicAuth: []
  - ApiKeyAuth: []
tags:
  - name: Models
    description: Model listing and information
  - name: Chat Completions
    description: Chat-based text generation
  - name: Text Completions
    description: Text completion generation
  - name: Responses
    description: OpenAI Responses API compatible endpoints
  - name: OCR
    description: Optical character recognition for documents and images
  - name: Rerank
    description: Document reranking by relevance to a query
  - name: Embeddings
    description: Text embedding generation
  - name: Images
    description: Image generations, editing, and variations
  - name: Videos
    description: Video generation and management
  - name: Audio
    description: Speech synthesis and transcription
  - name: Count Tokens
    description: Token counting utilities
  - name: Batch
    description: Batch processing operations
  - name: Files
    description: File management operations
  - name: Containers
    description: Container management operations
  - name: Async Jobs
    description: Asynchronous job submission and retrieval endpoints
  - name: OpenAI Integration
    description: OpenAI-compatible API endpoints (/openai/*)
  - name: Azure Integration
    description: Azure OpenAI integration endpoints
  - name: Anthropic Integration
    description: Anthropic-compatible API endpoints (/anthropic/*)
  - name: GenAI Integration
    description: Google GenAI (Gemini) compatible API endpoints (/genai/*)
  - name: Bedrock Integration
    description: AWS Bedrock compatible API endpoints (/bedrock/*)
  - name: Cohere Integration
    description: Cohere compatible API endpoints (/cohere/*)
  - name: LiteLLM Integration
    description: LiteLLM proxy endpoints with multi-provider support (/litellm/*)
  - name: LangChain Integration
    description: LangChain compatible endpoints with multi-provider support (/langchain/*)
  - name: PydanticAI Integration
    description: >-
      PydanticAI compatible endpoints with multi-provider support
      (/pydanticai/*)
  - name: Health
    description: Health check endpoints
  - name: Configuration
    description: Configuration management endpoints
  - name: Session
    description: Session and authentication endpoints
  - name: Providers
    description: Provider management endpoints
  - name: Plugins
    description: Plugin management endpoints
  - name: MCP
    description: Model Context Protocol endpoints
  - name: Governance
    description: Virtual keys, teams, and customers management
  - name: Logging
    description: Log search and management endpoints
  - name: Cache
    description: Cache management endpoints
paths:
  /v1/videos:
    post:
      tags:
        - Videos
      summary: Generate a video
      description: >
        Creates a video generation job from a text prompt. This is an
        asynchronous operation

        that returns immediately with a job ID. Use the retrieve endpoint to
        check the status

        and get the video URL when generation is complete.
      operationId: videoGeneration
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - model
                - prompt
              properties:
                model:
                  type: string
                  description: Model identifier in format `provider/model`
                prompt:
                  type: string
                  description: Text prompt describing the video to generate
                input_reference:
                  type: string
                  description: >-
                    Optional reference image for image-to-video. OpenAI and
                    Gemini require a base64 data URL (e.g.,
                    `data:image/png;base64,...`). Runway and Replicate accept
                    both data URLs and plain URLs.
                seconds:
                  type: string
                  description: Duration of the video in seconds as a string (e.g., "4")
                size:
                  type: string
                  description: >-
                    Resolution of the generated video (e.g., `1280x720`,
                    `720x1280`, `1920x1080`)
                negative_prompt:
                  type: string
                  description: Text describing what to avoid in the generated video
                seed:
                  type: integer
                  description: Seed for reproducible generation
                video_uri:
                  type: string
                  description: >-
                    Source video URI for video-to-video generation
                    (provider-specific, e.g. GCS URI)
                audio:
                  type: boolean
                  description: >-
                    Enable audio generation in the video (supported by select
                    providers/models)
                fallbacks:
                  type: array
                  items:
                    $ref: '#/components/schemas/Fallback'
                  description: Fallback models to try if primary model fails
      responses:
        '200':
          description: >
            Successful response. Returns a video generation job object with
            status information.

            Poll the retrieve endpoint to check completion status.
          content:
            application/json:
              schema:
                type: object
                properties:
                  id:
                    type: string
                    description: >-
                      Provider-native job ID. To use in path parameters
                      (retrieve/delete/download), combine as `{id}:{provider}`
                      (e.g., `task_abc123:runway`)
                  object:
                    type: string
                    enum:
                      - video
                    description: Object type, always "video"
                  model:
                    type: string
                    description: Model used for video generation
                  status:
                    type: string
                    enum:
                      - queued
                      - in_progress
                      - completed
                      - failed
                    description: |
                      Current lifecycle status of the video generation job:
                      - `queued`: Job is waiting to be processed
                      - `in_progress`: Video is currently being generated
                      - `completed`: Video generation completed successfully
                      - `failed`: Video generation failed
                  progress:
                    type: number
                    format: float
                    minimum: 0
                    maximum: 100
                    description: Approximate completion percentage (0-100)
                  prompt:
                    type: string
                    description: Prompt used to generate the video
                  remixed_from_video_id:
                    type: string
                    description: Source video ID if this is a remix
                  seconds:
                    type: string
                    description: >-
                      Duration of the generated video in seconds as a string
                      (e.g., "4")
                  size:
                    type: string
                    description: Resolution of the generated video (e.g., "1920x1080")
                  created_at:
                    type: integer
                    format: int64
                    description: Unix timestamp (seconds) when the job was created
                  completed_at:
                    type: integer
                    format: int64
                    description: Unix timestamp (seconds) when the job completed
                  expires_at:
                    type: integer
                    format: int64
                    description: Unix timestamp (seconds) when downloadable assets expire
                  videos:
                    type: array
                    description: >-
                      Generated video outputs (only present when status is
                      "completed")
                    items:
                      type: object
                      properties:
                        type:
                          type: string
                          enum:
                            - url
                            - base64
                          description: Output format of this video
                        url:
                          type: string
                          format: uri
                          description: >-
                            URL to the generated video (present when type is
                            "url")
                        base64:
                          type: string
                          description: >-
                            Base64-encoded video content (present when type is
                            "base64")
                        content_type:
                          type: string
                          description: MIME type of the video (e.g., "video/mp4")
                  error:
                    type: object
                    properties:
                      code:
                        type: string
                        description: Error code
                      message:
                        type: string
                        description: Human-readable error message
                  content_filter:
                    type: object
                    description: >-
                      Information about content that was filtered due to safety
                      policies
                    properties:
                      filtered_count:
                        type: integer
                        description: Number of items filtered
                      reasons:
                        type: array
                        items:
                          type: string
                        description: Human-readable reasons for filtering
                  extra_fields:
                    $ref: '#/components/schemas/BifrostResponseExtraFields'
        '400':
          description: Bad request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BifrostError'
        '500':
          description: Internal server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BifrostError'
      security:
        - BearerAuth: []
        - BasicAuth: []
        - VirtualKeyAuth: []
        - ApiKeyAuth: []
components:
  schemas:
    Fallback:
      type: object
      description: Fallback model configuration
      required:
        - provider
        - model
      properties:
        provider:
          $ref: '#/components/schemas/ModelProvider'
        model:
          type: string
          description: Model name
    BifrostResponseExtraFields:
      type: object
      description: Additional fields included in responses
      properties:
        request_type:
          type: string
          description: Type of request that was made
        provider:
          $ref: '#/components/schemas/ModelProvider'
        model_requested:
          type: string
          description: The model that was requested
        model_deployment:
          type: string
          description: The actual model deployment used
        latency:
          type: integer
          format: int64
          description: Request latency in milliseconds
        chunk_index:
          type: integer
          description: Index of the chunk for streaming responses
        raw_request:
          type: object
          description: Raw request if enabled
        raw_response:
          type: object
          description: Raw response if enabled
        cache_debug:
          $ref: '#/components/schemas/BifrostCacheDebug'
    BifrostError:
      type: object
      description: Error response from Bifrost
      properties:
        event_id:
          type: string
        type:
          type: string
        is_bifrost_error:
          type: boolean
        status_code:
          type: integer
        error:
          $ref: '#/components/schemas/ErrorField'
        extra_fields:
          $ref: '#/components/schemas/BifrostErrorExtraFields'
    ModelProvider:
      type: string
      description: AI model provider identifier
      enum:
        - openai
        - azure
        - anthropic
        - bedrock
        - cohere
        - vertex
        - vllm
        - mistral
        - ollama
        - groq
        - sgl
        - parasail
        - perplexity
        - replicate
        - cerebras
        - gemini
        - openrouter
        - elevenlabs
        - huggingface
        - nebius
        - xai
        - runway
        - fireworks
    BifrostCacheDebug:
      type: object
      properties:
        cache_hit:
          type: boolean
        cache_id:
          type: string
        hit_type:
          type: string
        requested_provider:
          type: string
        requested_model:
          type: string
        provider_used:
          type: string
        model_used:
          type: string
        input_tokens:
          type: integer
        threshold:
          type: number
        similarity:
          type: number
    ErrorField:
      type: object
      properties:
        type:
          type: string
        code:
          type: string
        message:
          type: string
        param:
          type: string
        event_id:
          type: string
    BifrostErrorExtraFields:
      type: object
      properties:
        provider:
          $ref: '#/components/schemas/ModelProvider'
        model_requested:
          type: string
        request_type:
          type: string
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >
        Bearer token authentication. Use your provider API key or Bifrost
        authentication token.

        Virtual keys (prefixed with `sk-bf-`) can also be passed here.
    BasicAuth:
      type: http
      scheme: basic
      description: |
        Basic authentication using username and password.
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: |
        API key authentication via the `x-api-key` header.
        Virtual keys (prefixed with `sk-bf-`) can also be passed here.
    VirtualKeyAuth:
      type: apiKey
      in: header
      name: x-bf-vk
      description: >
        Bifrost Virtual Key for governance, routing, and access control.
        Supported on all inference endpoints (`/v1/*`, `/openai/*`,
        `/anthropic/*`, `/bedrock/*`, `/cohere/*`, `/genai/*`, `/langchain/*`,
        `/litellm/*`, `/pydanticai/*`, `/mcp`), not on management APIs
        (`/api/*`).

        Example: `sk-bf-*` prefixed keys.

````