### Install the SDK

Source: https://context7.com/severecloud/vksdk/llms.txt

Use the go get command to add the library to your project.

```bash
go get github.com/SevereCloud/vksdk/v3@latest
```

--------------------------------

### Install VK SDK for Golang

Source: https://github.com/severecloud/vksdk/blob/master/README.md

Use this command to add the latest version of the VK SDK to your Go project.

```bash
# go mod init mymodulename
go get github.com/SevereCloud/vksdk/v3@latest
```

--------------------------------

### Initialize and Run Streaming API

Source: https://context7.com/severecloud/vksdk/llms.txt

Initializes the Streaming API client, adds keyword rules, retrieves current rules, and starts the streaming process to handle events.

```go
package main

import (
    "log"

    "github.com/SevereCloud/vksdk/v3/api"
    "github.com/SevereCloud/vksdk/v3/streaming"
)

func main() {
    vk := api.NewVK("<SERVICE_TOKEN>")

    // Initialize streaming
    s, err := streaming.NewStreaming(vk)
    if err != nil {
        log.Fatal(err)
    }

    // Add keyword rules (max 300 rules)
    err = s.AddRule("golang", "golang OR \"go language\" -game")
    if err != nil {
        log.Fatal(err)
    }

    err = s.AddRule("vk-api", "vk api OR vksdk")
    if err != nil {
        log.Fatal(err)
    }

    // List current rules
    rules, err := s.GetRules()
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Active rules: %d", len(rules))

    // Handle streaming events
    s.OnEvent(func(e streaming.Event) {
        log.Printf("[%s] %s: %s", e.EventType, e.Author.ID, e.Text)
    })

    // Start streaming (blocking)
    log.Println("Starting stream...")
    if err := s.Run(); err != nil {
        log.Fatal(err)
    }
}
```

--------------------------------

### Basic VK Bot with Long Poll

Source: https://github.com/severecloud/vksdk/blob/master/README.md

This example demonstrates setting up a basic VK bot using the Bots Long Poll API. It initializes the SDK, fetches group information, and sets up a handler for new messages. The bot responds with 'pong' when it receives a 'ping' message.

```go
package main

import (
	"context"
	"log"

	"github.com/SevereCloud/vksdk/v3/api"
	"github.com/SevereCloud/vksdk/v3/api/params"
	"github.com/SevereCloud/vksdk/v3/events"
	"github.com/SevereCloud/vksdk/v3/longpoll-bot"
)

func main() {

token := "<TOKEN>" // use os.Getenv("TOKEN")
vk := api.NewVK(token)

	// get information about the group
	group, err := vk.GroupsGetByID(nil)
	if err != nil {
		log.Fatal(err)
	}

	// Initializing Long Poll
	lp, err := longpoll.NewLongPoll(vk, group[0].ID)
	if err != nil {
		log.Fatal(err)
	}

	// New message event
	lp.MessageNew(func(_ context.Context, obj events.MessageNewObject) {
		log.Printf("%d: %s", obj.Message.PeerID, obj.Message.Text)

		if obj.Message.Text == "ping" {
			b := params.NewMessagesSendBuilder()
			b.Message("pong")
			b.RandomID(0)
			b.PeerID(obj.Message.PeerID)

			_, err := vk.MessagesSend(b.Params)
			if err != nil {
				log.Fatal(err)
			}
		}
	})

	// Run Bots Long Poll
	log.Println("Start Long Poll")
	if err := lp.Run(); err != nil {
		log.Fatal(err)
	}
}
```

--------------------------------

### Initialize and Run User Long Poll

Source: https://context7.com/severecloud/vksdk/llms.txt

Initializes the User Long Poll client with specified modes and starts the polling process. Handles raw events and typed events using a wrapper.

```go
package main

import (
    "log"

    "github.com/SevereCloud/vksdk/v3/api"
    longpoll "github.com/SevereCloud/vksdk/v3/longpoll-user"
    "github.com/SevereCloud/vksdk/v3/longpoll-user/v3/wrapper"
)

func main() {
    vk := api.NewVK("<USER_TOKEN>")

    // Initialize with mode flags
    mode := longpoll.ReceiveAttachments + longpoll.ExtendedEvents
    lp, err := longpoll.NewLongPoll(vk, mode)
    if err != nil {
        log.Fatal(err)
    }

    // Raw event handler (event code 4 = new message)
    lp.EventNew(4, func(event []interface{}) error {
        messageText := event[5].(string)
        log.Printf("New message: %s", messageText)
        return nil
    })

    // Full response handler for advanced use
    lp.FullResponse(func(resp object.LongPollResponse) {
        log.Printf("TS: %d, Updates: %d", resp.Ts, len(resp.Updates))
    })

    // Using v3 wrapper for typed events
    w := wrapper.NewWrapper(lp)
    w.OnNewMessage(func(m wrapper.NewMessage) {
        log.Printf("Message from %d: %s", m.PeerID, m.Text)
    })

    // Start polling
    log.Println("Starting User Long Poll...")
    if err := lp.Run(); err != nil {
        log.Fatal(err)
    }
}
```

--------------------------------

### Implement Bots Long Poll API

Source: https://context7.com/severecloud/vksdk/llms.txt

Handle real-time community events using the Long Polling mechanism. This implementation includes an echo bot example and context-aware event processing.

```go
package main

import (
    "context"
    "log"

    "github.com/SevereCloud/vksdk/v3/api"
    "github.com/SevereCloud/vksdk/v3/api/params"
    "github.com/SevereCloud/vksdk/v3/events"
    longpoll "github.com/SevereCloud/vksdk/v3/longpoll-bot"
)

func main() {
    vk := api.NewVK("<GROUP_TOKEN>")

    // Get group info
    groups, err := vk.GroupsGetByID(nil)
    if err != nil {
        log.Fatal(err)
    }

    // Initialize Long Poll
    lp, err := longpoll.NewLongPoll(vk, groups[0].ID)
    if err != nil {
        log.Fatal(err)
    }

    // Handle new messages
    lp.MessageNew(func(ctx context.Context, obj events.MessageNewObject) {
        log.Printf("New message from %d: %s", obj.Message.PeerID, obj.Message.Text)

        // Echo bot example
        if obj.Message.Text == "ping" {
            b := params.NewMessagesSendBuilder()
            b.PeerID(obj.Message.PeerID)
            b.RandomID(0)
            b.Message("pong")

            _, err := vk.MessagesSend(b.Params)
            if err != nil {
                log.Printf("Error sending message: %v", err)
            }
        }
    })

    // Handle member joins
    lp.GroupJoin(func(ctx context.Context, obj events.GroupJoinObject) {
        log.Printf("User %d joined the group", obj.UserID)
    })

    // Get context information
    lp.MessageNew(func(ctx context.Context, obj events.MessageNewObject) {
        groupID := events.GroupIDFromContext(ctx)
        eventID := events.EventIDFromContext(ctx)
        ts := longpoll.TsFromContext(ctx)
        log.Printf("Event %s in group %d at ts %s", eventID, groupID, ts)
    })

    // Start Long Poll (blocking)
    log.Println("Starting Long Poll...")
    if err := lp.Run(); err != nil {
        log.Fatal(err)
    }
}
```

--------------------------------

### Initialize Core API Client

Source: https://context7.com/severecloud/vksdk/llms.txt

Create an API client instance and configure rate limits based on the token type.

```go
package main

import (
    "log"

    "github.com/SevereCloud/vksdk/v3/api"
)

func main() {
    // Initialize the API client with an access token
    vk := api.NewVK("<TOKEN>")

    // Set rate limit (default: 20 requests/second for group tokens)
    vk.Limit = api.LimitGroupToken // 20 req/sec
    // vk.Limit = api.LimitUserToken // 3 req/sec for user tokens

    // Get user information
    users, err := vk.UsersGet(api.Params{
        "user_ids": "1,2,3",
        "fields":   "photo_200,city,verified",
    })
    if err != nil {
        log.Fatal(err)
    }

    for _, user := range users {
        log.Printf("User: %s %s (ID: %d)", user.FirstName, user.LastName, user.ID)
    }
}
```

--------------------------------

### Implement Callback API

Source: https://context7.com/severecloud/vksdk/llms.txt

Set up a webhook-based server to receive community events. Includes support for secret keys and automatic server configuration.

```go
package main

import (
    "context"
    "log"
    "net/http"

    "github.com/SevereCloud/vksdk/v3/api"
    "github.com/SevereCloud/vksdk/v3/callback"
    "github.com/SevereCloud/vksdk/v3/events"
)

func main() {
    vk := api.NewVK("<GROUP_TOKEN>")

    cb := callback.NewCallback()

    // Set confirmation key (from VK community settings)
    cb.ConfirmationKey = "your_confirmation_string"
    // Or per-group: cb.ConfirmationKeys[170561776] = "confirmation_string"

    // Set secret key for request verification
    cb.SecretKey = "your_secret_key"
    // Or per-group: cb.SecretKeys[170561776] = "secret_key"

    // Handle new messages
    cb.MessageNew(func(ctx context.Context, obj events.MessageNewObject) {
        groupID := events.GroupIDFromContext(ctx)
        log.Printf("[Group %d] Message: %s", groupID, obj.Message.Text)
    })

    // Handle wall posts
    cb.WallPostNew(func(ctx context.Context, obj events.WallPostNewObject) {
        log.Printf("New wall post: %s", obj.Text)
    })

    // Set up HTTP handler
    http.HandleFunc("/callback", cb.HandleFunc)

    // Optional: Auto-configure callback server
    cb.Title = "my-bot"
    go func() {
        err := cb.AutoSetting(vk, "https://example.com/callback")
        if err != nil {
            log.Printf("AutoSetting error: %v", err)
        }
    }()

    log.Println("Starting callback server on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

--------------------------------

### Implement OAuth Authentication Flows

Source: https://context7.com/severecloud/vksdk/llms.txt

Demonstrates Authorization Code Flow for users and groups, as well as the Implicit Flow for client-side applications.

```go
package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/SevereCloud/vksdk/v3/api/oauth"
)

func main() {
    clientID := 123456
    clientSecret := "your_client_secret"

    // Authorization Code Flow for users
    acf := oauth.NewAuthCodeFlowUser(oauth.UserParams{
        ClientID:    clientID,
        RedirectURI: "https://example.com/callback",
        Scope:       oauth.ScopeUserPhotos + oauth.ScopeUserFriends,
    }, clientSecret)

    // Generate authorization URL
    authURL := acf.URL().String()
    fmt.Printf("Redirect user to: %s\n", authURL)

    // Handle callback
    http.HandleFunc("/callback", func(w http.ResponseWriter, r *http.Request) {
        token, err := acf.Token(r.URL)
        if err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }

        fmt.Fprintf(w, "Token: %s\nUser ID: %d\nExpires in: %d seconds",
            token.AccessToken, token.UserID, token.ExpiresIn)
    })

    // Authorization Code Flow for groups
    gcf := oauth.NewAuthCodeFlowGroup(oauth.GroupParams{
        ClientID:    clientID,
        GroupIDs:    []int{12345, 67890},
        RedirectURI: "https://example.com/group-callback",
        Scope:       oauth.ScopeGroupMessages + oauth.ScopeGroupManage,
    }, clientSecret)

    groupAuthURL := gcf.URL().String()
    fmt.Printf("Group auth URL: %s\n", groupAuthURL)

    // Implicit Flow (for client-side apps)
    implicitURL := oauth.ImplicitFlowUser(oauth.UserParams{
        ClientID: clientID,
        Scope:    oauth.ScopeUserPhotos,
    })
    fmt.Printf("Implicit flow URL: %s\n", implicitURL.String())

    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

--------------------------------

### Verify VK Mini Apps Launch Parameters

Source: https://context7.com/severecloud/vksdk/llms.txt

Verifies launch parameters from a URL using the provided client secret. Can also be used as middleware for automatic verification of incoming HTTP requests.

```go
package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/SevereCloud/vksdk/v3/vkapps"
)

func main() {
    clientSecret := "your_app_secret"

    // Verify launch parameters from URL
    launchURL := "https://example.com/?vk_user_id=494075&vk_app_id=6736218&vk_is_app_user=1&sign=..."
    valid, err := vkapps.ParamsVerify(launchURL, clientSecret)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Parameters valid: %v\n", valid)

    // Use middleware for automatic verification
    pv := vkapps.NewParamsVerification(clientSecret)

    // Protected API handlers
    http.HandleFunc("/api/user", func(w http.ResponseWriter, r *http.Request) {
        pv.VerifyMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // Handler code - only reached if signature is valid
            w.Write([]byte(`{"status": "ok"}`))
        })).ServeHTTP(w, r)
    })

    // Public handlers (no verification)
    http.HandleFunc("/public", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Public content"))
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

--------------------------------

### Enable MessagePack and Zstd Compression

Source: https://context7.com/severecloud/vksdk/llms.txt

Use these methods to reduce bandwidth usage and improve response times by enabling binary serialization and zstd compression.

```go
package main

import (
    "log"

    "github.com/SevereCloud/vksdk/v3/api"
)

func main() {
    vk := api.NewVK("<TOKEN>")

    // Enable MessagePack (binary format, smaller than JSON)
    vk.EnableMessagePack()

    // Enable zstd compression (faster than gzip)
    vk.EnableZstd()

    // Make API requests with optimized encoding
    users, err := vk.UsersGet(api.Params{"user_ids": 1})
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("User: %s %s", users[0].FirstName, users[0].LastName)
}
```

--------------------------------

### Configure Custom HTTP Client with Proxy

Source: https://context7.com/severecloud/vksdk/llms.txt

Override the default HTTP client to route requests through a SOCKS5 proxy or apply custom transport settings.

```go
package main

import (
    "log"
    "net/http"

    "github.com/SevereCloud/vksdk/v3/api"
    "golang.org/x/net/proxy"
)

func main() {
    vk := api.NewVK("<TOKEN>")

    // Configure SOCKS5 proxy
    dialer, err := proxy.SOCKS5("tcp", "127.0.0.1:9050", nil, proxy.Direct)
    if err != nil {
        log.Fatal(err)
    }

    httpTransport := &http.Transport{
        Dial: dialer.Dial,
    }

    vk.Client = &http.Client{
        Transport: httpTransport,
    }

    // All requests will now go through the proxy
    users, err := vk.UsersGet(api.Params{"user_ids": 1})
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("User: %s", users[0].FirstName)
}
```

--------------------------------

### Construct Requests with Parameter Builders

Source: https://context7.com/severecloud/vksdk/llms.txt

Utilize type-safe builders to construct API requests with IDE autocompletion support.

```go
package main

import (
    "log"

    "github.com/SevereCloud/vksdk/v3/api"
    "github.com/SevereCloud/vksdk/v3/api/params"
)

func main() {
    vk := api.NewVK("<TOKEN>")

    // Use parameter builder for type-safe request construction
    b := params.NewMessagesSendBuilder()
    b.PeerID(123456789)
    b.RandomID(0)
    b.Message("Hello from VK SDK!")
    b.DontParseLinks(false)

    // Send the message
    messageID, err := vk.MessagesSend(b.Params)
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Message sent with ID: %d", messageID)
}
```

--------------------------------

### Execute Batch API Calls

Source: https://context7.com/severecloud/vksdk/llms.txt

Run multiple API methods in a single request using VKScript to optimize performance.

```go
package main

import (
    "log"

    "github.com/SevereCloud/vksdk/v3/api"
)

func main() {
    vk := api.NewVK("<TOKEN>")

    // Define response structure
    var response struct {
        User struct {
            ID        int    `json:"id"`
            FirstName string `json:"first_name"`
        } `json:"user"`
        FriendsCount int `json:"friends_count"`
    }

    // Execute VKScript code
    code := `
        var user = API.users.get({"user_ids": 1})[0];
        var friends = API.friends.get({"user_id": 1});
        return {
            "user": user,
            "friends_count": friends.count
        };
    `

    err := vk.Execute(code, &response)
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("User: %s (ID: %d), Friends: %d",
        response.User.FirstName, response.User.ID, response.FriendsCount)
}
```

--------------------------------

### Upload Photo to Album

Source: https://context7.com/severecloud/vksdk/llms.txt

Uploads a photo from a local file to a specified VK album. Requires the album ID and a valid user token.

```go
package main

import (
    "log"
    "net/http"
    "os"

    "github.com/SevereCloud/vksdk/v3/api"
)

func main() {
    vk := api.NewVK("<TOKEN>")

    // Upload photo from file
    file, err := os.Open("photo.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    // Upload to album
    photo, err := vk.UploadPhoto(123456789, file) // albumID
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Uploaded to album: photo%d_%d", photo[0].OwnerID, photo[0].ID)

    // Upload from URL
    resp, err := http.Get("https://example.com/image.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    // Upload to wall
    wallPhoto, err := vk.UploadWallPhoto(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Wall photo: photo%d_%d", wallPhoto[0].OwnerID, wallPhoto[0].ID)

    // Upload to message
    msgPhoto, err := vk.UploadMessagesPhoto(123456789, file) // peerID
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Message photo: %s", msgPhoto[0].ToAttachment())
}
```

--------------------------------

### Create Marusia Voice Skill

Source: https://context7.com/severecloud/vksdk/llms.txt

Implements a webhook handler for Marusia voice assistant events, including utterance processing and button interactions.

```go
package main

import (
    "encoding/json"
    "log"
    "net/http"

    "github.com/SevereCloud/vksdk/v3/marusia"
)

type MyPayload struct {
    Action string `json:"action"`
    marusia.DefaultPayload
}

func main() {
    wh := marusia.NewWebhook()

    // Enable CORS for local debugging
    // wh.EnableDebuging()

    wh.OnEvent(func(r marusia.Request) (resp marusia.Response) {
        switch r.Request.Type {
        case marusia.SimpleUtterance:
            switch r.Request.Command {
            case marusia.OnStart:
                resp.Text = "Welcome to my skill!"
                resp.TTS = "Welcome to my skill! What would you like to do?"
                resp.AddButton("Help", MyPayload{Action: "help"})
                resp.AddButton("Exit", nil)

            case "help":
                resp.Text = "I can tell you jokes or play games."
                resp.TTS = "I can tell you jokes or play games. What would you like?"

            case marusia.OnInterrupt:
                resp.Text = "Goodbye!"
                resp.TTS = "Goodbye! See you next time."
                resp.EndSession = true

            default:
                resp.Text = "I didn't understand. Say 'help' for options."
                resp.TTS = "Sorry, I didn't understand. Say help for options."
            }

        case marusia.ButtonPressed:
            var p MyPayload
            if err := json.Unmarshal(r.Request.Payload, &p); err != nil {
                resp.Text = "Error processing button"
                return
            }

            if p.Action == "help" {
                resp.Text = "Here's how I can help..."
            }

        case marusia.DeepLink:
            resp.Text = "Opened via deep link"
        }

        // Add images
        // resp.Card = marusia.NewBigImage("Title", "Description", imageID)
        // resp.Card = marusia.NewImageList(imageID1, imageID2)

        return
    })

    http.HandleFunc("/webhook", wh.HandleFunc)
    log.Println("Marusia skill running on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

--------------------------------

### Manage Token Pool for High Throughput

Source: https://context7.com/severecloud/vksdk/llms.txt

Uses multiple access tokens in a round-robin fashion to increase the effective API request rate limit.

```go
package main

import (
    "log"
    "sync"

    "github.com/SevereCloud/vksdk/v3/api"
)

func main() {
    // Initialize with multiple tokens for load distribution
    tokens := []string{
        "<TOKEN_1>",
        "<TOKEN_2>",
        "<TOKEN_3>",
    }

    vk := api.NewVK(tokens...)

    // Each request automatically uses the next token (round-robin)
    // Effective rate limit = 20 * len(tokens) = 60 req/sec

    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(userID int) {
            defer wg.Done()

            users, err := vk.UsersGet(api.Params{
                "user_ids": userID,
            })
            if err != nil {
                log.Printf("Error for user %d: %v", userID, err)
                return
            }

            log.Printf("User %d: %s", userID, users[0].FirstName)
        }(i + 1)
    }

    wg.Wait()
}
```

--------------------------------

### Upload Document to Messages

Source: https://context7.com/severecloud/vksdk/llms.txt

Uploads a document or an audio message to a conversation. Requires the peer ID, type, title, tags, and the file content.

```go
package main

import (
    "log"
    "os"

    "github.com/SevereCloud/vksdk/v3/api"
)

func main() {
    vk := api.NewVK("<TOKEN>")

    // Upload document to messages
    file, err := os.Open("document.pdf")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    doc, err := vk.UploadMessagesDoc(
        123456789,        // peerID
        "doc",            // type: "doc" or "audio_message"
        "document.pdf",   // title
        "pdf,report",     // tags
        file,
    )
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Document: doc%d_%d", doc.Doc.OwnerID, doc.Doc.ID)

    // Upload voice message (Ogg Opus format)
    audioFile, err := os.Open("voice.ogg")
    if err != nil {
        log.Fatal(err)
    }
    defer audioFile.Close()

    voiceDoc, err := vk.UploadMessagesDoc(
        123456789,
        "audio_message",
        "voice.ogg",
        "",
        audioFile,
    )
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Voice message: doc%d_%d", voiceDoc.Doc.OwnerID, voiceDoc.Doc.ID)
}
```

--------------------------------

### Handle VK Payments Notifications

Source: https://context7.com/severecloud/vksdk/llms.txt

Processes VK payment notifications for in-app purchases and subscriptions. Sets up handlers for product info, order status changes, and subscription status changes.

```go
package main

import (
    "log"
    "net/http"

    "github.com/SevereCloud/vksdk/v3/payments"
)

func main() {
    cb := payments.NewCallback("your_api_secret")

    // Handle product info requests
    cb.OnGetItem(func(e payments.GetItemRequest) (*payments.GetItemResponse, *payments.Error) {
        log.Printf("GetItem: user=%d, item=%s", e.UserID, e.Item)

        // Return product information
        return &payments.GetItemResponse{
            Title:    "Premium Subscription",
            Price:    100, // in votes
            PhotoURL: "https://example.com/premium.png",
            ItemID:   "premium_monthly",
        }, nil
    })

    // Handle order status changes
    cb.OnOrderStatusChange(func(e payments.OrderStatusChangeRequest) (
        *payments.OrderStatusChangeResponse,
        *payments.Error,
    ) {
        log.Printf("Order %d status: %s", e.OrderID, e.Status)

        if e.Status == payments.Chargeable {
            // Process the payment, grant items to user
            return &payments.OrderStatusChangeResponse{
                OrderID:    e.OrderID,
                AppOrderID: 12345, // your internal order ID
            }, nil
        }

        if e.Status == payments.Refunded {
            // Handle refund - remove items from user
            log.Printf("Refund for order %d", e.OrderID)
        }

        return &payments.OrderStatusChangeResponse{OrderID: e.OrderID}, nil
    })

    // Handle subscription info requests
    cb.OnGetSubscription(func(e payments.GetSubscriptionRequest) (
        *payments.GetSubscriptionResponse,
        *payments.Error,
    ) {
        return &payments.GetSubscriptionResponse{
            Title:    "VIP Monthly",
            Price:    50,
            Period:   30, // days: 3, 7, or 30
            ItemID:   1,
        }, nil
    })

    // Handle subscription status changes
    cb.OnSubscriptionStatusChange(func(e payments.SubscriptionStatusChangeRequest) (
        *payments.SubscriptionStatusChangeResponse,
        *payments.Error,
    ) {
        switch e.Status {
        case payments.Active:
            log.Printf("Subscription %d activated", e.SubscriptionID)
        case payments.Cancelled:
            log.Printf("Subscription %d cancelled: %s", e.SubscriptionID, e.CancelReason)
        }

        return &payments.SubscriptionStatusChangeResponse{
            SubscriptionID: e.SubscriptionID,
        }, nil
    })

    http.HandleFunc("/payments", cb.HandleFunc)
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

--------------------------------

### Handle API Errors

Source: https://context7.com/severecloud/vksdk/llms.txt

Implement error handling using Go 1.13+ error wrapping and specific API error types.

```go
package main

import (
    "errors"
    "log"

    "github.com/SevereCloud/vksdk/v3/api"
)

func main() {
    vk := api.NewVK("<TOKEN>")

    _, err := vk.UsersGet(api.Params{"user_ids": 1})
    if err != nil {
        // Check for specific error types
        if errors.Is(err, api.ErrAuth) {
            log.Println("Authorization failed - invalid token")
            return
        }

        // Handle API errors with detailed information
        var e *api.Error
        if errors.As(err, &e) {
            switch e.Code {
            case api.ErrCaptcha:
                log.Printf("Captcha required - SID: %s, Image: %s", e.CaptchaSID, e.CaptchaImg)
                // Re-submit request with captcha_sid and captcha_key params
            case api.ErrTooMany:
                log.Println("Rate limit exceeded - too many requests per second")
            default:
                log.Printf("API Error %d: %s", e.Code, e.Text)
            }
        }
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.