Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.legnext.ai/llms.txt

Use this file to discover all available pages before exploring further.

​
GenerateVideo()

Generate a video from text prompt, image URL, or existing generated image. 
package main

import (
    "context"
    "fmt"
    "os"
    legnext "github.com/legnext-ai/sdks/sdks/go"
)

func main() {
    config := legnext.NewConfiguration()
    config.Servers = legnext.ServerConfigurations{
        {
            URL: "https://api.legnext.ai",
        },
    }

    apiKey := os.Getenv("LEGNEXT_API_KEY")
    config.AddDefaultHeader("x-api-key", apiKey)

    client := legnext.NewAPIClient(config)
    ctx := context.Background()

    // Option 1: Generate from text only
    prompt := "a flowing river through mountains"
    videoType := int32(1) // 0=480p, 1=720p
    callback := "https://your-domain.com/webhook"

    request := legnext.VideoDiffusionRequest{
        Prompt:    &prompt,
        VideoType: &videoType,
        Callback:  &callback,
    }

    response, httpRes, err := client.VideoGenerationAPI.GenerateVideo(ctx).
        VideoDiffusionRequest(request).
        Execute()

    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Printf("Job ID: %s\n", *response.JobId)
    fmt.Printf("Status: %s\n", *response.Status)
}
Option 2: Generate from Image URL: 
// Generate from image URL
prompt := "https://example.com/image.png a flowing river through mountains"
videoType := int32(1)
callback := "https://your-domain.com/webhook"

request := legnext.VideoDiffusionRequest{
    Prompt:    &prompt,
    VideoType: &videoType,
    Callback:  &callback,
}

response, httpRes, err := client.VideoGenerationAPI.GenerateVideo(ctx).
    VideoDiffusionRequest(request).
    Execute()

if err != nil {
    fmt.Printf("Error: %v\n", err)
    return
}

fmt.Printf("Job ID: %s\n", *response.JobId)
Option 3: Animate Generated Image: 
// Animate from previously generated image
originalJobId := "image-generation-job-id"
imageNo := int32(0)
videoType := int32(1)
callback := "https://your-domain.com/webhook"

request := legnext.VideoDiffusionRequest{
    JobId:     &originalJobId,
    ImageNo:   &imageNo,
    VideoType: &videoType,
    Callback:  &callback,
}

response, httpRes, err := client.VideoGenerationAPI.GenerateVideo(ctx).
    VideoDiffusionRequest(request).
    Execute()

if err != nil {
    fmt.Printf("Error: %v\n", err)
    return
}

fmt.Printf("Job ID: %s\n", *response.JobId)
Parameters:
  • Prompt (string, conditional): Video prompt or “[image_url] prompt text” (1-8192 characters) - required for text/URL mode
  • JobId (string, conditional): Original image generation job ID - required for image animation mode
  • ImageNo (int32, conditional): Image index (0-3) - required when using JobId
  • VideoType (int32, optional): Quality (0=480p, 1=720p)
  • Callback (string, optional): Webhook URL
Returns: Response with JobId and Status

​
ExtendVideo()

Extend an existing video. 
jobId := "original-video-job-id"
videoNo := int32(0)
prompt := "continue with dramatic lighting"
callback := "https://your-domain.com/webhook"

request := legnext.ExtendVideoRequest{
    JobId:    &jobId,
    VideoNo:  &videoNo,
    Prompt:   &prompt,
    Callback: &callback,
}

response, httpRes, err := client.VideoGenerationAPI.ExtendVideo(ctx).
    ExtendVideoRequest(request).
    Execute()

if err != nil {
    fmt.Printf("Error: %v\n", err)
    return
}

fmt.Printf("Extension Job ID: %s\n", *response.JobId)
Parameters:
  • JobId (string): Original video task ID
  • VideoNo (int32): Video index (0-3)
  • Prompt (string, optional): Extension prompt (1-8192 characters)
  • Callback (string, optional): Webhook URL
Returns: Response with JobId and Status

​
UpscaleVideo()

Upscale video to higher resolution. 
jobId := "original-video-job-id"
videoNo := int32(0)
callback := "https://your-domain.com/webhook"

request := legnext.VideoUpscaleRequest{
    JobId:    &jobId,
    VideoNo:  &videoNo,
    Callback: &callback,
}

response, httpRes, err := client.VideoGenerationAPI.UpscaleVideo(ctx).
    VideoUpscaleRequest(request).
    Execute()

if err != nil {
    fmt.Printf("Error: %v\n", err)
    return
}

fmt.Printf("Upscale Job ID: %s\n", *response.JobId)
Parameters:
  • JobId (string): Original video task ID
  • VideoNo (int32): Video index (0-3)
  • Callback (string, optional): Webhook URL
Returns: Response with JobId and Status

​
Complete Example

package main

import (
    "context"
    "fmt"
    "os"
    legnext "github.com/legnext-ai/sdks/sdks/go"
)

func main() {
    // Configure API client
    config := legnext.NewConfiguration()
    config.Servers = legnext.ServerConfigurations{
        {
            URL: "https://api.legnext.ai",
        },
    }

    apiKey := os.Getenv("LEGNEXT_API_KEY")
    if apiKey == "" {
        fmt.Println("LEGNEXT_API_KEY environment variable not set")
        return
    }

    config.AddDefaultHeader("x-api-key", apiKey)

    client := legnext.NewAPIClient(config)
    ctx := context.Background()

    // Step 1: Generate video
    prompt := "a beautiful sunset over the ocean"
    videoType := int32(1)

    request := legnext.VideoDiffusionRequest{
        Prompt:    &prompt,
        VideoType: &videoType,
    }

    response, _, err := client.VideoGenerationAPI.GenerateVideo(ctx).
        VideoDiffusionRequest(request).
        Execute()

    if err != nil {
        fmt.Printf("Error generating video: %v\n", err)
        return
    }

    jobId := *response.JobId
    fmt.Printf("Video generation started: %s\n", jobId)

    // Step 2: Wait for completion (see Task Management docs)
    // ...

    // Step 3: Extend the video
    videoNo := int32(0)
    extendPrompt := "continue with dramatic clouds"

    extendRequest := legnext.ExtendVideoRequest{
        JobId:   &jobId,
        VideoNo: &videoNo,
        Prompt:  &extendPrompt,
    }

    extendResponse, _, err := client.VideoGenerationAPI.ExtendVideo(ctx).
        ExtendVideoRequest(extendRequest).
        Execute()

    if err != nil {
        fmt.Printf("Error extending video: %v\n", err)
        return
    }

    fmt.Printf("Video extension started: %s\n", *extendResponse.JobId)

    // Step 4: Upscale the extended video
    upscaleRequest := legnext.VideoUpscaleRequest{
        JobId:   extendResponse.JobId,
        VideoNo: &videoNo,
    }

    upscaleResponse, _, err := client.VideoGenerationAPI.UpscaleVideo(ctx).
        VideoUpscaleRequest(upscaleRequest).
        Execute()

    if err != nil {
        fmt.Printf("Error upscaling video: %v\n", err)
        return
    }

    fmt.Printf("Video upscale started: %s\n", *upscaleResponse.JobId)
}

​
Error Handling

response, httpRes, err := client.VideoGenerationAPI.GenerateVideo(ctx).
    VideoDiffusionRequest(request).
    Execute()

if err != nil {
    if httpRes != nil {
        switch httpRes.StatusCode {
        case 400:
            fmt.Println("Validation error: Check request parameters")
        case 401:
            fmt.Println("Authentication error: Invalid API key")
        case 404:
            fmt.Println("Resource not found")
        case 429:
            fmt.Println("Rate limit exceeded. Please retry later.")
        case 500, 502, 503:
            fmt.Println("Server error. Please retry.")
        default:
            fmt.Printf("API error (%d): %v\n", httpRes.StatusCode, err)
        }
    } else {
        fmt.Printf("Unexpected error: %v\n", err)
    }
    return
}

​
Next Steps