Sockets you don’t have to run.

Three prefixes, and the prefix is the rule.

A channel’s name decides who may join it. There is no second permission model to keep in step with the first — the gateway parses the name.

public-

Open to anyone holding the key

A public key is meant to sit in a browser. Anyone with it can subscribe and read; only your server can write. Right for tickers, build status, anything already on the page.

private-

Your server decides who joins

The client asks your auth endpoint, which signs the subscription with your secret key. The gateway checks that signature before the socket joins the room. You already know who your user is — this is where you say so.

presence-

Private, and it keeps the roster

Everything a private channel does, plus who is here. Members arrive with the subscription, and joins and departures are pushed as they happen. You do not maintain the list.

Three steps, and the middle one is conditional.

One install, a public key and a secret key. Both keys are minted the moment you create an app, and the secret is shown exactly once.

1. 01

   Subscribe in the browser

   The public key belongs here. That is what it is for.

   import { Socketly } from '@socketly/client';
   
   const socketly = new Socketly({
     key: process.env.NEXT_PUBLIC_SOCKETLY_KEY!,
     authEndpoint: '/api/socketly/auth',
   });
   
   socketly
     .subscribe('presence-room-42')
     .bind('new-message', ({ data }) => render(data));

2. 02

   Authorize, for private and presence channels

   One endpoint, and the only step that asks anything of you. Public channels skip it.

   import { authorizeChannel } from '@socketly/server';
   
   export async function POST(request: Request) {
     const { socket_id, channel_name } = await request.json();
   
     const user = await getCurrentUser();
     if (!user) return new Response('Unauthorized', { status: 401 });
   
     return Response.json(
       await authorizeChannel({
         secret: process.env.SOCKETLY_SECRET!,
         socketId: socket_id,
         channel: channel_name,
         userData: { user_id: user.id, user_info: { name: user.name } },
       }),
     );
   }

3. 03

   Publish from your server

   The secret key never leaves it.

   import { SocketlyServer } from '@socketly/server';
   
   const socketly = new SocketlyServer({
     secret: process.env.SOCKETLY_SECRET!,
   });
   
   await socketly.trigger('presence-room-42', 'new-message', {
     text: 'Shipped.',
   });

The rest — channels, keys and the React hooks — is in the docs.

Or let your agent do it — and check its own work.

@socketly/mcp gives a coding agent five tools and these docs as a resource. It can publish an event, watch the channel, and see the message arrive — so it finds out whether the code it just wrote works, instead of telling you it does.

claude mcp add socketly \
  --env SOCKETLY_SECRET_KEY=sk_app_… \
  --env SOCKETLY_PUBLIC_KEY=pk_app_… \
  -- npx -y @socketly/mcp

Works with Claude Code, Claude Desktop, Cursor, Windsurf and anything else that speaks MCP. How it works.

Plans

Every number below is read from the constants the gateway enforces, so this page cannot drift from the product.

A message counts once when you publish it and once for each connected client we deliver it to, the same way the rest of this category counts. The free plan also includes one workspace.