Lix.li Go SDK

// Create a basic link
result, err := client.Links().Create("https://example.com", nil)
fmt.Println(result.Link.ShortURL)

// With custom alias and UTM
opts := lix.NewCreateLinkOptions()
opts.Alias = strPtr("my-link")
opts.Title = strPtr("My Page Title")
opts.Tags = []string{"sale", "promo"}
opts.UTM = map[string]string{
    "utm_source":  "google",
    "utm_medium":  "email",
    "utm_campaign": "summer",
}
opts.TrackingPixelIDs = []int{1001, 1002}
opts.IsPublic = true

result, err := client.Links().Create("https://example.com", opts)

// Password protection + expiration
opts := lix.NewCreateLinkOptions()
opts.Password = strPtr("secret123")
opts.ActiveBeforeDatetime = strPtr("2026-12-31T23:59:59+00:00")
result, err := client.Links().Create("https://example.com", opts)

func strPtr(s string) *string { return &s }

// Create a regular group
group, err := client.Groups().Create("Marketing", nil, false)
fmt.Println(group.Name, group.URL)

// Create a rotating group for A/B testing
group, err := client.Groups().Create(
    "Landing Pages",
    strPtr("Rotating pages"),
    true,
)

// Update group
group, err := client.Groups().Update(
    10, nil,
    strPtr("Updated description"),
    false,
)

// List with pagination
limit := 10
page, err := client.Groups().List(&limit, nil)
for _, g := range page.Groups {
    fmt.Println(g.Name, g.URL)
}
fmt.Println(page.Meta.Total)

profile, err := client.Profile().Me()
if err != nil {
    log.Fatal(err)
}

// Account info
fmt.Println(profile.Client.Name, profile.Client.Email)
fmt.Println(profile.User.Email)

// Plan details
fmt.Println(profile.Plan.Name, profile.Plan.EndDatetime)

// Usage limits
if profile.Usages.Links.Remaining != nil {
    fmt.Println(*profile.Usages.Links.Remaining)
}
fmt.Println(profile.Usages.APILinks.Used)
fmt.Println(profile.Usages.MassLinks.Limit)

import "errors"

result, err := client.Links().Create("invalid-url", nil)
if err != nil {
    var ve *lix.ValidationError
    var notFound *lix.NotFoundException
    var unauth *lix.UnauthorizedError
    var rateLimit *lix.RateLimitError
    var server *lix.ServerError

    switch {
    case errors.As(err, &ve):
        // Field-level validation errors
        fmt.Println("Validation:", ve.Data)
    case errors.As(err, &notFound):
        fmt.Println("Not found")
    case errors.As(err, &unauth):
        // Invalid API key
    case errors.As(err, &rateLimit):
        // Too many requests
    case errors.As(err, &server):
        // 5xx server error
    default:
        // Generic Lix or network error
        log.Fatal(err)
    }
}