Overview of Channel API for Java


The Channel API creates a persistent connection between your application and Google servers, allowing your application to send messages to JavaScript clients in real time without the use of polling. This API is useful for applications that are designed to update users about new information immediately. Some example use-cases include collaborative applications, multi-player games, or chat rooms. In general, using the Channel API is a better choice than polling in situations where updates can't be predicted or scripted, such as when relaying information between human users or from events not generated systematically.

Elements of the Channel API

Javascript client

The user interacts with a JavaScript client built into a webpage. The JavaScript client is primarily responsible for three things:

  • Connecting to the channel after it receives the channel's unique token from the server.
  • Listening on the channel for updates regarding other clients and making appropriate use of the data, such as updating the interface.
  • Sending update messages to the server so they may be passed on to remote clients.

For details on building your client, refer to the JavaScript Reference.

The server

The server is responsible for:

  • Creating a unique channel for individual JavaScript clients.
  • Creating and sending a unique token to each JavaScript client so they can connect and listen to their channel.
  • Receiving update messages from clients via HTTP requests.
  • Sending update messages to clients via their channels.
  • Optionally, managing client connection state.

The client ID

The client ID is responsible for identifying individual JavaScript clients on the server. The server knows what channel on which to send a particular message because of the client ID.

A client ID can be anything that makes sense in the design of your application. For example, you can use something like cookie or login information, randomized numerical ID, or a user-selected name.

You can also create client IDs in whatever way makes sense in your application. For example, you might choose to create the client ID on the client and pass it to the server in an explicit request for a token, or create it on the server and inject it into the page's HTML when the server replies to the browser's request for the page.


Tokens are responsible for allowing the JavaScript client to connect and listen to the channel created for it. The server creates one token for each client using information such as the client’s Client ID and expiration time.

Tokens expire after two hours and should also be treated as secret. For more details, see the Tokens and Security section.

The channel

A channel is a one-way communication path through which the server sends updates to a specific JavaScript client identified by its Client ID. The server receives updates from clients via HTTP requests, then sends the messages to relevant clients via their channels.

The message

Messages are sent via HTTP requests from one client to the server. When a message is received, the server passes the message to the designated client via the correct channel identified by the client ID. Messages are limited to 32K.


The JavaScript client opens a socket using the token provided by the server. It uses the socket to listen for updates on the channel.


The server can register to receive a notification when a client connects to or disconnects from a channel.

Life of a typical channel message

These two diagrams illustrate the life of a typical example message sent via Channel API between two different clients using one possible implementation of Channel API.

This diagram shows the creation of a channel on the server. This example shows the JavaScript client explicitly request a token and send its client ID to the server. In contrast, you could choose to design your application to inject the token into the client before the page loads in the browser, or some other implementation if preferred.

Next, the server uses client A’s client ID to create a channel and then sends the token for that channel back to client A. Client A uses the token to open a socket and listen for updates on the channel.

This diagram shows client B sending a message using HTTP POST to the server. The server processes the message and sends it to client A over the channel. Client A receives the message and makes use of the new information.

Sending messages to different app versions

The ChannelMessage class can be initialized with a token passed as the clientId parameter. This allows applications to send the message object from different versions of the app. For instance you could create the channel on the front end and then send messages from a backend of the app.

Example Tic Tac Toe application

To better illustrate how to use Channel API, take a look at the following example Tic Tac Toe game application written in Java. The game allows users to create a game, invite another player by sending out a URL, and play the game together in real time. The application updates both players' views of the board in real time as soon as the other player makes a move.

The full source code of the application is available at the Java Channel Tac Toe Project page. We'll go over major highlights that illustrate Channel API below.

Creating and connecting to a channel

When a user visits the Tic Tac Toe game for the first time, two things happen:

  • The game servlet injects a token into the html page sent to the client. The client uses this token to open a socket and listen for updates on the channel.
  • The game servlet provides the user with a URL they can share with a friend in order to invite him or her to join the game.

In order to initiate the process of creating a channel, Java applications call the ChannelServiceFactory.getChannelService() method and get a ChannelService() object. Then they use the object's createChannel() method and get a token that the client page can use to connect to the channel. When calling createChannel(), they send a Client ID that uniquely identifies the client to the server.

ChannelService channelService = ChannelServiceFactory.getChannelService();

// The 'Game' object exposes a method which creates a unique string based on the game's key
// and the user's id.
String token = channelService.createChannel(game.getChannelKey(userId));

The server returns the token to the client, which injects it into the index.html resource template and creates a new goog.appengine.Channel() object.

var token = '<%= request.getAttribute("token") %>';
var channel = new goog.appengine.Channel(token);
var handler = {
  'onopen': onOpened,
  'onmessage': onMessage,
  'onerror': function() {},
  'onclose': function() {}
var socket = channel.open(handler);
socket.onopen = onOpened;
socket.onmessage = onMessage;

The game client uses the Channel object's open() method to create a socket. The client also sets callback functions on the socket to be called when the state of the socket changes.

Opening the socket

In our example, when the Tic Tac Toe client is ready to receive messages, it calls the onOpened() function, which is set to the socket's onopen callback. The onOpened function also updates the UI for the user to indicate that the game is ready to play and sends a POST message to the server to ask it to send the latest game state.

The following client-side JavaScript code implements this functionality:

sendMessage = function(path, opt_param) {
  path += '?g=' + state.game_key;
  if (opt_param) {
    path += '&' + opt_param;
  var xhr = new XMLHttpRequest();
  xhr.open('POST', path, true);

onOpened = function() {

Note that the application defines sendMessage() as a wrapper around XmlHttpRequest, which the client uses to send messages to the server.

Updating the game state

The Tic Tac Toe Javascript client uses an onClick handler called moveInSquare to handle mouse clicks in the board. When a player makes a move in the Tic Tac Toe applicaiton by clicking on a square, the client uses XmlHttpRequest to send a HTTP POST message to the application with the proposed move.

The following client Javascript code snippet sends the message to the server:

moveInSquare = function(id) {
  if (isMyMove() && state.board[id] == ' ') {
    sendMessage('/move', 'i=' + id);

Validating and sending the new game state

Use an HTTP request to send messages from the client to the server. In this example, when the server receives the client's message via an HTTP request, it first uses its request handler to validate the move. Then, if the move is legal, the server uses the ChannelService.sendMessage() method to send messages indicating the new state of the board to both clients.

public String getChannelKey(String user) {
  return user + "." + id;

private void sendUpdateToUser(String user) {
  if (user != null) {
    ChannelService channelService = ChannelServiceFactory.getChannelService();
    String channelKey = getChannelKey(user);
    channelService.sendMessage(new ChannelMessage(channelKey, getMessageString()));

public void sendUpdateToClients() {
public boolean makeMove(int position, String user) {
  String currentMovePlayer;
  char value;
  if (getMoveX()) {
    value = 'X';
    currentMovePlayer = getUserX();
  } else {
    value = 'O';
    currentMovePlayer = getUserO();

  if (currentMovePlayer.equals(user)) {
    char[] boardBytes = getBoard().toCharArray();
    boardBytes[position] = value;
    setBoard(new String(boardBytes));
    return true;

  return false;

Tracking client connections and disconnections

Applications can request to be notified when a client connects to or disconnects from a channel.

You can enable this inbound service in appengine-web.xml:

<!-- Optional: Enable Inbound Service to get notified when a client connects to or disconnects from a channel -->

When you enable channel_presence, your application receives HTTP POST requests to the following URL paths:

  • HTTP POST requests to /_ah/channel/connected/ signal that the client has connected to the channel and can receive messages.
  • HTTP POST requests to /_ah/channel/disconnected/ signal that the client has disconnected from the channel.

Your application can register handlers to these paths in order to receive notifications. You can use these notifications to track which clients are currently connected.

You can use the ChannelService class's parsePresence() to retrieve the client_id of the connected or disconnected channel.