slack-web-api

Slack Web API

Core API Pattern

All Web API methods follow this pattern:

result, err := api.MethodName(params...)
if err != nil {
    // Handle error (rate limits, permissions, etc.)
    return err
}
// Use result

Messaging Operations

Send Simple Text Message

channelID := "C1234567890"
text := "Hello, Slack!"

_, _, err := api.PostMessage(
    channelID,
    slack.MsgOptionText(text, false),
)

Send Message with Block Kit

headerText := slack.NewTextBlockObject("mrkdwn", "*Deployment Complete*", false, false)
headerBlock := slack.NewSectionBlock(headerText, nil, nil)

divider := slack.NewDividerBlock()

bodyText := slack.NewTextBlockObject("mrkdwn", "Version 2.1.0 deployed successfully", false, false)
bodyBlock := slack.NewSectionBlock(bodyText, nil, nil)

_, _, err := api.PostMessage(
    channelID,
    slack.MsgOptionBlocks(headerBlock, divider, bodyBlock),
)

See web-api-messaging.md for comprehensive messaging patterns including threading, updates, and ephemeral messages.

Channel Operations

Create a Channel

channelName := "project-updates"
isPrivate := false

channel, err := api.CreateConversation(channelName, isPrivate)
if err != nil {
    return err
}
fmt.Printf("Created channel: %s (ID: %s)\n", channel.Name, channel.ID)

List Channels

params := &slack.GetConversationsParameters{
    Types: []string{"public_channel"},
    Limit: 100,
}

channels, nextCursor, err := api.GetConversations(params)

See web-api-channels.md for channel management, invites, and metadata operations.

User Operations

Get User Information

user, err := api.GetUserInfo("U1234567890")
if err != nil {
    return err
}

fmt.Printf("User: %s (%s)\n", user.Profile.RealName, user.Profile.Email)

List All Users

users, err := api.GetUsers()
if err != nil {
    return err
}

for _, user := range users {
    fmt.Printf("- %s (%s)\n", user.Name, user.ID)
}

See web-api-users.md for user presence, profiles, and groups.

File Operations

Upload a File

params := slack.FileUploadParameters{
    File:     "report.pdf",
    Channels: []string{"C1234567890"},
    Title:    "Monthly Report",
}

file, err := api.UploadFile(params)
if err != nil {
    return err
}

See web-api-files.md for file downloads, sharing, and multi-part uploads.

Block Kit Integration

Block Kit allows rich, interactive messages. See block-kit-integration.md for:

• Section blocks with text, images, and accessories
• Interactive buttons and select menus
• Input blocks for forms
• Complete layout patterns

Canvas, Calls, and Assistant Threads

Create a Canvas

canvasID, err := api.CreateCanvasContext(ctx, "Sprint Planning", slack.DocumentContent{
    Type:     "markdown",
    Markdown: "# Sprint Planning\n\n## Goals",
})

See canvas-api.md for editing, access control, and section lookups.

Register a Call

call, err := api.AddCallContext(ctx, slack.AddCallParameters{
    JoinURL:          "https://calls.example.com/join/abc123",
    ExternalUniqueID: "call-abc123",
    CreatedBy:        "U1234567890",
})

See calls-api.md for updating, ending, and managing participants.

AI Assistant Threads

err := api.SetAssistantThreadsStatusContext(ctx, slack.AssistantThreadsSetStatusParameters{
    ChannelID: channelID,
    ThreadTS:  threadTS,
    Status:    "is thinking...",
})

See assistant-api.md for suggested prompts, thread titles, and context search. This is Slack's AI-assistant-app surface, not a general LLM API.

Error Handling

Rate Limiting

_, _, err := api.PostMessage(channelID, slack.MsgOptionText(text, false))
if err != nil {
    if rateLimitErr, ok := err.(*slack.RateLimitedError); ok {
        time.Sleep(rateLimitErr.RetryAfter)
        // Retry operation
    }
    return err
}

Common Error Types

• slack.RateLimitedError - Too many requests
• Permission errors - Missing scopes
• channel_not_found - Invalid channel ID
• invalid_auth - Token issues

Pagination

For operations returning large result sets, use cursor-based pagination:

cursor := ""
for {
    params := &slack.GetConversationsParameters{
        Cursor: cursor,
        Limit:  100,
    }

    channels, nextCursor, err := api.GetConversations(params)
    if err != nil {
        return err
    }

    // Process channels...

    if nextCursor == "" {
        break
    }
    cursor = nextCursor
}

See pagination-patterns.md for advanced pagination strategies.

Common Pitfalls

• Not handling rate limits (use exponential backoff)
• Hardcoding channel/user IDs (use lookups or environment variables)
• Forgetting to escape user input in messages
• Not validating Bot Token scopes match required permissions
• Using blocking operations in high-throughput scenarios