Skip to content
Switch branches/tags
This branch is up to date with version/4.

Latest commit


Git stats


Failed to load latest commit information.


Maven Central Build Status

jSlack is a Java library to easily integrate your operations with Slack. The library currently supports the following APIs.

Getting Started

Check the latest version on the Maven Central repository.

API Client

The following is an example using Maven. Of course, it's also possible to grab the library via Gradle, sbt and any other build tools.

If you really don't need classes for building Slack app backend (= you need only Webhook/Web API/RTM API clients), just depending on jslack-api-client would be enough.

<version>{latest version}</version>

The {latest version} is Maven Central

See also: Getting started with groovysh

Slack App Server-side Framework

Lightning is a framework to build Slack apps on the JVM.

Yes, as you noticed, Lightning is highly inspired by Bolt. The framework offers an abstraction layer on top of the web service infrastructure (e.g., Servlet API). The abstraction enables developers to focus on the essential parts of Slack app development.

Lighning is available on the Maven Central repository.

Java / Maven
    <version>{latest version}</version>
  <!-- if you go with Jetty server -->
    <version>{latest version}</version>

The {latest version} is Maven Central

import com.github.seratch.jslack.lightning.App;

// export SLACK_BOT_TOKEN=xoxb-***
// export SLACK_SIGNING_SECRET=123abc***
App app = new App();

// Handles requests triggered by /echo
app.command("/echo", (req, ctx) -> {
  // Context#respond sends a message using payload.responseUrl
  ctx.respond(r -> r.text(req.getPayload().getText()));
  // Context#ack returns 200 OK response to the request
  return ctx.ack();

import com.github.seratch.jslack.lightning.jetty.SlackAppServer;

SlackAppServer server = new SlackAppServer(app);
server.start(); // http://localhost:3000

API Client Examples

If you like using Kotlin, check this repository as well 🙌

Incoming Webhooks

Incoming Webhooks is a simple way to post messages from external sources into Slack via ordinary HTTP requests.

jSlack naturally wraps its interface in Java. After lightly reading the official guide, you should be able to use it immediately.

import com.github.seratch.jslack.*;
import com.github.seratch.jslack.api.webhook.*;

String url = System.getenv("SLACK_WEBHOOK_URL");

Payload payload = Payload.builder().text("Hello World!").build();

Slack slack = Slack.getInstance();
WebhookResponse response = slack.send(url, payload);
// response.code, response.message, response.body

Here is a small example using Block Kit.

import static com.github.seratch.jslack.api.webhook.WebhookPayloads.*;
import static com.github.seratch.jslack.api.model.block.Blocks.*;
import static com.github.seratch.jslack.api.model.block.element.BlockElements.*;
import static com.github.seratch.jslack.api.model.block.composition.BlockCompositions.*;

Payload payload = payload(b -> b.blocks(
    actions(a -> a.elements(asElements(
      button(bt -> bt.text(plainText(pt -> pt.emoji(true).text("label"))).value("value"))

Slack slack = Slack.getInstance();
WebhookResponse response = slack.send(url, payload);
// response.code, response.message, response.body

It's also possible to directly give a raw payload.

String payload = "{\"text\": \"Hi there!\"}";
WebhookResponse response = slack.send(url, payload);

API Methods

There are lots of APIs to integrate external sources into Slack. They follow HTTP RPC-style methods.

When the API call has been completed successfully, its response contains "ok": true and other specific fields.

    "ok": true

In some cases, it may contain warning field too.

    "ok": true,
    "warning": "something_problematic"

When the API call failed or had some warnings, its response contains "ok": false' and also have the error field which holds a string error code.

    "ok": false,
    "error": "something_bad"

jSlack simply wrap API interface. Find more examples in this library's test code.

import com.github.seratch.jslack.*;
import com.github.seratch.jslack.api.methods.request.conversations.*;
import com.github.seratch.jslack.api.methods.response.conversations.*;

Slack slack = Slack.getInstance();

String token = System.getenv("SLACK_BOT_TEST_API_TOKEN");
ConversationsCreateRequest req = ConversationsCreateRequest.builder().name(channelName).isPrivate(false).build();
ConversationsCreateResponse resp = slack.methods(token).conversationsCreate(publicChannelCreation);

Or, using lambda function to build a request could be much simpler. You don't need to type the long class name!

final String token = System.getenv("SLACK_BOT_TEST_API_TOKEN");
ChannelsCreateResponse response =
  slack.methods(token).conversationsCreate(req ->;

API Methods Examples

You can find more examples here:

Post a message to a channel
Slack slack = Slack.getInstance();
String token = "xoxb-************************************";

// find all channels in the team
ConversationsListResponse listResponse = 
  slack.methods(token).conversationsList(req -> req.excludeArchived(true).limit(10));

// find #general
Conversation general = listResponse.getChannels().stream()
  .filter(c -> c.getName().equals("general"))

ChatPostMessageResponse postResponse =
  slack.methods(token).chatPostMessage(req ->"Hello World!"));

// timestamp of the posted message
String messageTs = postResponse.getMessage().getTs();

ChatDeleteResponse deleteResponse =
  slack.methods(token).chatDelete(req ->;
Open a Block Kit modal
import com.github.seratch.jslack.lightning.App;
import com.github.seratch.jslack.api.methods.response.views.ViewsOpenResponse;
import com.github.seratch.jslack.api.model.view.View;
import static com.github.seratch.jslack.api.model.block.Blocks.*;
import static com.github.seratch.jslack.api.model.block.composition.BlockCompositions.*;
import static com.github.seratch.jslack.api.model.view.Views.*;

App app = new App();

View view = view(r -> { return r
  .title(viewTitle(t -> t.text("My App")))
  .submit(viewSubmit(s -> s.text("Submit")))
  .close(viewClose(c -> c.text("Close")))
    section(sec -> sec.text(plainText(pt -> pt.text("Hi")))),
    image(img -> img.imageUrl(""))

app.command("/open-modal", (req, ctx) -> {
  ViewsOpenResponse apiRes = ctx.client().viewsOpen(r -> r
    .view(view) // or .viewAsString(stringValue)
  if (apiRes.isOk()) return ctx.ack();
  else return ctx.ack(r -> r.text("Failed to open a modal (error: " + apiRes.getError() + ")"));

Events API

The Events API is a streamlined, easy way to build apps and bots that respond to activities in Slack. All you need is a Slack app and a secure place for us to send your events.

AppUninstalledHandler appUninstalledEventHandler = new AppUninstalledHandler {
  public void handle(AppUninstalledPayload event) {
    // do something here

public class SampleServlet extends SlackEventsApiServlet {
  protected void setupDispatcher(EventsDispatcher dispatcher) {

With Lightning, event handlers can be simpler:

App app = new App();

app.event(MessageEvent.class, (event, ctx) -> {
  if (isRequest(event.getEvent().getText())) {
    ChatPostMessage response = ctx.client().chatPostMessage(r ->"I got it!"));
    if (!response.isOk()) {
        // error handling
  return ctx.ack();
app.event(MessageDeletedEvent.class, (event, ctx) -> {
  return ctx.ack();

Slack App Backend Examples

jSlack offers a full-stack Slack app framework named Lightning. Check its README to learn the basics first.

import com.github.seratch.jslack.lightning.App
import com.github.seratch.jslack.lightning.jetty.SlackAppServer
import org.slf4j.LoggerFactory

fun main() {

    val logger = LoggerFactory.getLogger("main")

    // export SLACK_BOT_TOKEN=xoxb-***
    // export SLACK_SIGNING_SECRET=123abc***
    val app = App()

    app.command("/echo") { req, ctx ->
        val text = "You said ${req.payload.text} at <#${req.payload.channelId}|${req.payload.channelName}>"
        val res = ctx.respond { it.text(text) }"respond result - {}", res)

    // Amazon Elastic Container Service - the default health check endpoint
    // [ "CMD-SHELL", "curl -f http://localhost/ || exit 1" ]
    app.endpoint("/") { _, ctx ->

    // export SLACK_PORT=8080
    val envPort: String? = System.getenv()["SLACK_PORT"]
    val port: Int = if (envPort == null) 8080 else Integer.valueOf(envPort)
    val server = SlackAppServer(app, port)

Also, there are lots of working examples:

Real Time Messaging API

Real Time Messaging API is a WebSocket-based API that allows you to receive events from Slack in real time and send messages as user.

When you use this API through jSlack library, you need adding additional WebSocket libraries:


The following example shows you a simple usage of RTM API.

import com.github.seratch.jslack.*;
import com.github.seratch.jslack.api.rtm.*;

JsonParser jsonParser = new JsonParser();
String token = System.getenv("SLACK_BOT_API_TOKEN");

try (RTMClient rtm = new Slack().rtm(token)) {

  rtm.addMessageHandler((message) -> {
    JsonObject json = jsonParser.parse(message).getAsJsonObject();
    if (json.get("type") != null) {"Handled type: {}", json.get("type").getAsString());

  RTMMessageHandler handler2 = (message) -> {"Hello!");


  // must connect within 30 seconds after issuing wss endpoint




} // #close method does #disconnect

The message, argument of messageHandler, is a string value in JSON format. You need to deserialize it with your favorite JSON library.

jSlack already depends on google-gson library. So you can use Gson as above example shows. If you prefer Jackson or other libraries, it's also possible.


// users
User newUser = buildNewUser(); // omitted
UsersCreateResponse creationResp = slack.scim(token).createUser(req -> req.user(newUser));

String filter = "userName eq \"" + newUser.getUserName() + "\"";
UsersSearchResponse searchResp = slack.scim(token).searchUsers(req -> req.count(1).filter(filter));
assertThat(searchResp.getItemsPerPage(), is(1));
assertThat(searchResp.getResources().size(), is(1));

User partialUpdate = new User();
slack.scim(token).patchUser(req ->;

slack.scim(token).updateUser(req ->;

// groups
GroupsSearchResponse pagination = slack.scim(token).searchGroups(req -> req.count(1));

Audit Logs API

SchemasResponse response = slack.audit(token).getSchemas();
ActionsResponse response = slack.audit(token).getActions();
LogsResponse response = slack.audit(token).getLogs(req -> req.oldest(1521214343).action("user_login").limit(10));

(jSlack's Original) Shortcut APIs

Slack slack = Slack.getInstance();
ApiToken token = ApiToken.of(System.getenv("SLACK_OAUTH_ACCESS_TOKEN"));

Shortcut shortcut = slack.shortcut(token);

List<Message> messages = shortcut.findRecentMessagesByName(ChannelName.of("general"));
ReactionsAddResponse addReaction = shortcut.addReaction(messages.get(0), ReactionName.of("smile"));

ChatPostMessageResponse response ="general"), "hello, hello!");

// Good old attachments
Attachment attachment = Attachment.builder().text("text").footer("footer").build();
List<Attachment> attachments = Arrays.asList(attachment);
ChatPostMessageResponse response = shortcut.postAsBot(ChannelName.of("general"), "hello, hello!");

// Block Kit
SectionBlock section = SectionBlock.builder()
  .text(MarkdownTextObject.builder().text("Some rich text").build())
  .accessory(ImageElement.builder().imageUrl("").altText("This is an image").build())

DividerBlock divider = new DividerBlock();

ChatPostMessageResponse response ="general"),
  Arrays.asList(section, divider));

Preparations for running this library's unit tests.

Creating a Slack app

Setting up "OAuth & Permissions" for it

You need to select all permission scopes except for identity.*. After that, you also need to run "Reinstall App".

Setting up OAuth access tokens (both the normal one and the one as a bot)

Set the OAuth access tokens as env variables.

export SLACK_TEST_OAUTH_ACCESS_TOKEN=xoxp-*******************************************************
export SLACK_BOT_USER_TEST_OAUTH_ACCESS_TOKEN=xoxb-************************************

Creating at least one Slack user who has its email

Manually create a Slack user which has an email address for a unit test.

Create an incoming webhook url

export SLACK_WEBHOOK_TEST_CHANNEL=C12345678 (or #random)

Add to App Unfurl Domains

  • Features > Event Subscriptions > App Unfurl Domains
    • Add to the domain list
    • Re-install your Slack app

(Optional) Have a shared channel


(Optional) Have a multi-channel guest and a single-channel guest

(Optional) Have an access token to run tests with SCIM API and Audit Logs API


Run the tests

mvn test


mvn deploy -P release-sign-artifacts -D maven.test.skip=true


(The MIT License)

Copyright (c) Kazuhiro Sera


J2ObjC compilable jSlack (a Java Slack library)







No packages published