Go SDK

go get github.com/Canvelete/canvelete-go

package main
 
import (
    "context"
    "fmt"
    "log"
    
    "github.com/canvelete/canvelete-go/canvelete"
)
 
func main() {
    client := canvelete.NewClient("cvt_your_api_key")
    ctx := context.Background()
    
    // List designs
    designs, err := client.Designs.List(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Found %d designs\n", len(designs.Data))
    
    // Render a design
    err = client.Render.CreateAndSave(ctx, &canvelete.RenderRequest{
        DesignID: "design_123",
        Format:   "png",
        DynamicData: map[string]interface{}{
            "title": "Hello World",
        },
    }, "output.png")
    if err != nil {
        log.Fatal(err)
    }
}

client := canvelete.NewClient("cvt_your_api_key")

export CANVELETE_API_KEY="cvt_your_api_key"

import "os"
 
client := canvelete.NewClient(os.Getenv("CANVELETE_API_KEY"))

// Basic listing
designs, err := client.Designs.List(ctx, nil)
 
// With options
designs, err := client.Designs.List(ctx, &canvelete.ListOptions{
    Page:  1,
    Limit: 20,
})
 
// Iterate all (channel-based)
designChan, errChan := client.Designs.IterateAll(ctx, nil)
for design := range designChan {
    fmt.Println(design.Name)
}
if err := <-errChan; err != nil {
    log.Fatal(err)
}

design, err := client.Designs.Create(ctx, &canvelete.CreateDesignRequest{
    Name:   "My Design",
    Width:  1920,
    Height: 1080,
    CanvasData: map[string]interface{}{
        "elements": []map[string]interface{}{
            {
                "type":     "text",
                "text":     "{{title}}",
                "x":        100,
                "y":        100,
                "fontSize": 48,
            },
        },
    },
})

// Get
design, err := client.Designs.Get(ctx, "design_123")
 
// Update
name := "Updated Name"
design, err := client.Designs.Update(ctx, "design_123", &canvelete.UpdateDesignRequest{
    Name: &name,
})
 
// Delete
err := client.Designs.Delete(ctx, "design_123")

// Render to bytes
imageData, err := client.Render.Create(ctx, &canvelete.RenderRequest{
    DesignID: "design_123",
    Format:   "png",
    Quality:  90,
    DynamicData: map[string]interface{}{
        "title": "Hello World",
    },
})
 
// Render and save to file
err := client.Render.CreateAndSave(ctx, &canvelete.RenderRequest{
    DesignID: "design_123",
    Format:   "png",
}, "output.png")

result, err := client.Render.Create(ctx, &canvelete.RenderRequest{
    DesignID: "design_123",
    Format:   "pdf",    // png, jpg, pdf, svg, webp
    Quality:  95,       // 1-100
    Width:    1200,     // Custom width
    Height:   630,      // Custom height
    DynamicData: map[string]interface{}{
        "title": "Hello",
        "image": "https://example.com/photo.jpg",
    },
})

// List templates
templates, err := client.Templates.List(ctx, nil)
 
// With search
templates, err := client.Templates.List(ctx, &canvelete.TemplateListOptions{
    Search: "certificate",
})
 
// Get template
template, err := client.Templates.Get(ctx, "template_123")
 
// Iterate all
templateChan, errChan := client.Templates.IterateAll(ctx, nil)
for template := range templateChan {
    fmt.Println(template.Name)
}

design, err := client.Designs.Get(ctx, "invalid_id")
if err != nil {
    if apiErr, ok := err.(*canvelete.APIError); ok {
        switch apiErr.StatusCode {
        case 404:
            fmt.Println("Design not found")
        case 401:
            fmt.Println("Invalid API key")
        case 429:
            fmt.Println("Rate limited")
        default:
            fmt.Printf("API error: %v\n", apiErr)
        }
    } else {
        fmt.Printf("Request error: %v\n", err)
    }
}

// With timeout
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
 
designs, err := client.Designs.List(ctx, nil)

// With options
client := canvelete.NewClient("cvt_your_key",
    canvelete.WithBaseURL("https://api.canvelete.com"),
    canvelete.WithTimeout(60 * time.Second),
)
 
// Custom HTTP client
httpClient := &http.Client{
    Timeout: 60 * time.Second,
}
client := canvelete.NewClient("cvt_your_key",
    canvelete.WithHTTPClient(httpClient),
)