slack-go/slack Go Library

The library provides support for multiple communication protocols. For most modern applications, Socket Mode is recommended over RTM.

Refer to the following example paths for minimal implementations:

• Socket Mode: examples/socketmode/socketmode.go
• RTM (Websocket): examples/websocket/websocket.go
• EventsAPI: examples/eventsapi/events.go
• Socket Mode Event Handler (Experimental): Use SocketmodeHandler to register specific event types and callback functions, similar to an HTTP handler. See examples/socketmode_handler/socketmode_handler.go.

Use go get to install the library into your Go project.

go get -u github.com/slack-go/slack

Create a new Slack client using slack.New(token). You can optionally enable debugging to log all requests to the console using slack.OptionDebug(true), which is useful for troubleshooting.

import (
    "github.com/slack-go/slack"
)

api := slack.New("YOUR_TOKEN_HERE")
// To enable debugging:
// api := slack.New("YOUR_TOKEN_HERE", slack.OptionDebug(true))

Retries are disabled by default. To enable them, use OptionRetry or OptionRetryConfig when initializing your Slack client. Retries improve reliability during network flakiness or when Slack is busy.

Important Limitations:

• Requests that stream the body (like file uploads) cannot be retried because the body can only be sent once.
• Regular API calls (form or JSON) are retryable if the request body can be replayed (i.e., req.GetBody is implemented).

Use api.GetUserInfo(userID) to retrieve details about a specific user, such as their ID, real name, and email.

import (
    "fmt"
    "github.com/slack-go/slack"
)

func main() {
    api := slack.New("YOUR_TOKEN_HERE")
    user, err := api.GetUserInfo("U023BECGF")
    if err != nil {
        fmt.Printf("%s\n", err)
        return
    }
    fmt.Printf("ID: %s, Fullname: %s, Email: %s\n", user.ID, user.Profile.RealName, user.Profile.Email)
}

Use api.GetUserGroups to retrieve groups. You can pass options such as slack.GetUserGroupsOptionIncludeUsers(bool) to control whether user information is included in the response.

import (
    "fmt"
    "github.com/slack-go/slack"
)

func main() {
    api := slack.New("YOUR_TOKEN_HERE")
    groups, err := api.GetUserGroups(slack.GetUserGroupsOptionIncludeUsers(false))
    if err != nil {
        fmt.Printf("%s\n", err)
        return
    }
    for _, group := range groups {
        fmt.Printf("ID: %s, Name: %s\n", group.ID, group.Name)
    }
}

Retries are disabled by default. You can configure them using:

• OptionRetry(n): Enables retries specifically for 429 (Too Many Requests) errors.
• OptionRetryConfig(cfg): Provides full control over connection retries, 429 retries, and optional 5xx retries.

If using a custom HTTP client, pass retry options after OptionHTTPClient.

The PostMessageParameters struct allows for a single-object configuration of a message. While most users use MsgOption functions, you can use MsgOptionPostMessageParameters to pass this struct.

Fields include:

• Username (string)
• AsUser (bool)
• Parse (string: "full" or "none")
• ThreadTimestamp (string)
• ReplyBroadcast (bool)
• LinkNames (int)
• UnfurlLinks (bool)
• UnfurlMedia (bool)
• IconURL (string)
• IconEmoji (string)
• Markdown (bool)
• EscapeText (bool)
• Channel (string)
• User (string)
• MetaData (SlackMetadata)
• FileIDs ([]string)

The RetryConfig struct allows you to fine-tune how the client handles retries. You can use DefaultRetryConfig() to get a sensible starting point.

Fields:

• MaxRetries: Maximum number of retry attempts (0 = no retries).
• Handlers: A slice of RetryHandler to consult. If nil, only rate limits (429) are retried.
• RetryAfterDuration: Wait time for 429 errors when the Retry-After header is missing or invalid.
• RetryAfterJitter: Random jitter [0, RetryAfterJitter] added to 429 waits.
• BackoffInitial: Initial backoff duration for 5xx and connection errors.
• BackoffMax: Maximum cap for the backoff duration.
• BackoffJitter: Random jitter [0, BackoffJitter] added to exponential backoff.