Skip to main content
go-openai is a popular community-maintained Go client for the OpenAI API with over 9,000 GitHub stars. It provides a clean, idiomatic Go interface for OpenAI-compatible APIs.

​
Installation

go get github.com/sashabaranov/go-openai

​
Configuration

Configure the client to use Lumenfall’s API: 
package main

import (
    "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("lmnfl_your_api_key")
    config.BaseURL = "https://api.lumenfall.ai/openai/v1"

    client := openai.NewClientWithConfig(config)
}

​
Using environment variables

package main

import (
    "os"

    "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig(os.Getenv("LUMENFALL_API_KEY"))
    config.BaseURL = "https://api.lumenfall.ai/openai/v1"

    client := openai.NewClientWithConfig(config)
}

​
Generate images

package main

import (
    "context"
    "fmt"

    "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("lmnfl_your_api_key")
    config.BaseURL = "https://api.lumenfall.ai/openai/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateImage(
        context.Background(),
        openai.ImageRequest{
            Model:          "gemini-3-pro-image",
            Prompt:         "A serene mountain landscape at sunset with dramatic clouds",
            N:              1,
            Size:           openai.CreateImageSize1024x1024,
            ResponseFormat: openai.CreateImageResponseFormatURL,
        },
    )
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Println(resp.Data[0].URL)
}

​
Generation options

resp, err := client.CreateImage(
    context.Background(),
    openai.ImageRequest{
        Model:          "gpt-image-1.5",
        Prompt:         "A beautiful garden with roses",
        N:              1,
        Size:           openai.CreateImageSize1792x1024, // landscape
        Quality:        openai.CreateImageQualityHD,
        Style:          openai.CreateImageStyleNatural,
        ResponseFormat: openai.CreateImageResponseFormatURL,
    },
)

​
Available sizes

ConstantDimensions
CreateImageSize256x256256x256
CreateImageSize512x512512x512
CreateImageSize1024x10241024x1024
CreateImageSize1024x17921024x1792 (portrait)
CreateImageSize1792x10241792x1024 (landscape)

​
Get base64 response

resp, err := client.CreateImage(
    context.Background(),
    openai.ImageRequest{
        Model:          "gpt-image-1.5",
        Prompt:         "A cute robot painting",
        N:              1,
        ResponseFormat: openai.CreateImageResponseFormatB64JSON,
    },
)
if err != nil {
    fmt.Printf("Error: %v\n", err)
    return
}

base64Image := resp.Data[0].B64JSON

​
Edit images

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("lmnfl_your_api_key")
    config.BaseURL = "https://api.lumenfall.ai/openai/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateEditImage(
        context.Background(),
        openai.ImageEditRequest{
            Model:  "gpt-image-1.5",
            Image:  &os.File{}, // Open your image file
            Prompt: "Add a rainbow in the sky",
            N:      1,
            Size:   openai.CreateImageSize1024x1024,
        },
    )
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Println(resp.Data[0].URL)
}

​
Complete edit example with file handling

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("lmnfl_your_api_key")
    config.BaseURL = "https://api.lumenfall.ai/openai/v1"
    client := openai.NewClientWithConfig(config)

    // Open the image file
    imageFile, err := os.Open("original.png")
    if err != nil {
        fmt.Printf("Error opening image: %v\n", err)
        return
    }
    defer imageFile.Close()

    resp, err := client.CreateEditImage(
        context.Background(),
        openai.ImageEditRequest{
            Model:  "gpt-image-1.5",
            Image:  imageFile,
            Prompt: "Add a rainbow in the sky",
            N:      1,
            Size:   openai.CreateImageSize1024x1024,
        },
    )
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Println(resp.Data[0].URL)
}

​
With a mask

imageFile, _ := os.Open("original.png")
defer imageFile.Close()

maskFile, _ := os.Open("mask.png")
defer maskFile.Close()

resp, err := client.CreateEditImage(
    context.Background(),
    openai.ImageEditRequest{
        Model:  "gpt-image-1.5",
        Image:  imageFile,
        Mask:   maskFile,
        Prompt: "A sunlit indoor lounge area with a pool",
        N:      1,
        Size:   openai.CreateImageSize1024x1024,
    },
)

​
List models

package main

import (
    "context"
    "fmt"

    "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("lmnfl_your_api_key")
    config.BaseURL = "https://api.lumenfall.ai/openai/v1"
    client := openai.NewClientWithConfig(config)

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

    for _, model := range models.Models {
        fmt.Println(model.ID)
    }
}

​
Error handling

package main

import (
    "context"
    "errors"
    "fmt"

    "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("lmnfl_your_api_key")
    config.BaseURL = "https://api.lumenfall.ai/openai/v1"
    client := openai.NewClientWithConfig(config)

    resp, err := client.CreateImage(
        context.Background(),
        openai.ImageRequest{
            Model:  "gemini-3-pro-image",
            Prompt: "A beautiful sunset",
        },
    )

    if err != nil {
        var apiErr *openai.APIError
        if errors.As(err, &apiErr) {
            fmt.Printf("API Error: %s (code: %s)\n", apiErr.Message, apiErr.Code)
            switch apiErr.HTTPStatusCode {
            case 401:
                fmt.Println("Invalid API key")
            case 429:
                fmt.Println("Rate limit exceeded")
            case 402:
                fmt.Println("Insufficient balance")
            }
        } else {
            fmt.Printf("Error: %v\n", err)
        }
        return
    }

    fmt.Println(resp.Data[0].URL)
}

​
Concurrent image generation

package main

import (
    "context"
    "fmt"
    "sync"

    "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("lmnfl_your_api_key")
    config.BaseURL = "https://api.lumenfall.ai/openai/v1"
    client := openai.NewClientWithConfig(config)

    prompts := []string{
        "A serene mountain landscape",
        "A futuristic city skyline",
        "An underwater coral reef",
    }

    var wg sync.WaitGroup
    results := make(chan string, len(prompts))

    for _, prompt := range prompts {
        wg.Add(1)
        go func(p string) {
            defer wg.Done()

            resp, err := client.CreateImage(
                context.Background(),
                openai.ImageRequest{
                    Model:  "gemini-3-pro-image",
                    Prompt: p,
                    N:      1,
                    Size:   openai.CreateImageSize1024x1024,
                },
            )
            if err != nil {
                results <- fmt.Sprintf("Error for '%s': %v", p, err)
                return
            }
            results <- fmt.Sprintf("'%s': %s", p, resp.Data[0].URL)
        }(prompt)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    for result := range results {
        fmt.Println(result)
    }
}

​
Next steps

API Reference

Explore the full API documentation.

Available Models

See all available image generation models.