One player pool. Every app.
Parlor gives your app live games against real people, without you building any of it. Every app on the network contributes players to one shared pool, so matches fill in seconds.
The same live game, drawn by two different apps. Parlor holds the position, the clocks, and the rules. Clients just render.
Three calls to a live game.
Register in the console, mint a token, open a socket. The full REST and OpenAPI reference lives at /docs.
Mint a key in the console
Register your app and create a secret key. Keys are tenant-scoped. Yours cannot see another app's players.
# created in the console, kept server-side
export PARLOR_KEY="psk_YOUR_KEY"Mint a player token
Provision players by your own user ids. Parlor never sees emails or names. Tokens expire, so mint them from your server per session.
curl -X POST https://activities.daeila.com/v1/players/tokens \
-H "Authorization: Bearer psk_YOUR_KEY" \
-d '{"external_id":"user_42"}'
# { "token": "ppt_...", "expires_at": "..." }Queue up, render frames
Your client joins the matchmaking queue with the player token and opens the match socket. The server pushes authoritative state frames. Draw them in any UI.
{
"type": "state",
"fen": "r1bqk2r/ppp2ppp/2np1n2/2b1p1N1/2B1P3/2PP4/PP3PPP/RNBQK2R b KQkq - 5 6",
"turn": "black",
"clocks": { "white_ms": 158200, "black_ms": 153000 },
"last_move": "f3g5",
"status": "active"
}Liquidity is the product.
Matchmaking lives or dies on one number: how many compatible players are online right now. One app rarely has enough. A network does.
One shared pool
A player waiting out a loading screen in one app matches a player silencing an alarm in another. Neither leaves their app. Both get a real opponent.
Rating-banded queues
Matches start inside a tight Elo band. The band widens while you wait, so fairness degrades gracefully instead of the queue stalling.
About 15 seconds
The liquidity promise. If a fair human match has not filled in about 15 seconds, your app knows in time to offer a bot fallback. Private pools are available when you want matches kept inside your own user base.
The server is the referee.
Every game runs server-side. Clients render state and send intents. Nothing a client says is trusted.
- Server-authoritative movesEvery move is validated against the authoritative position before it stands. An illegal move is not a bug report. It is a rejected frame.
- Server clocks3+2 blitz timed where the game lives, with disconnect grace. Resign, timeout, and abandonment are all handled, not left to the client.
- One transactionResult and rating commit together. Each player carries one network-wide Elo, provisional badge under 10 games, and clients cannot forge any of it.
- Any rendererSwiftUI, web, VR. If it can draw a board and send a move, it can be a Parlor client.
Strangers, without the risk.
Cross-app play means your users meet people you did not vet. Parlor makes that boring.
Generated handles, assembled avatars
Every player gets a handle like SleepyKnight42 and a cartoon avatar built from enumerated parts. No usernames to review, no display-name policies to write.
Nothing to moderate
No free text between strangers. No uploads. Opponents see a handle, an avatar, a rating, and by default the app someone plays from. Nothing else crosses the wall.
AlarmMCP wakes people up with Parlor.
The wake check is a chess drill
AlarmMCP is an alarm app. Its morning wake check is a Parlor quick mode: a three-puzzle chess drill that takes under three minutes. Live chess in AlarmMCP rides the same network, against opponents from every other app on it.
Gates you can verify
The alarm counts as done only when Parlor's sessions API returns a completion receipt stamped by the server clock. Not when the client says so.
curl "https://activities.daeila.com/v1/sessions?ref=wake_user_42" \
-H "Authorization: Bearer psk_YOUR_KEY"
# { ..., "completed_received_at": "2026-07-14T07:03:11Z" }What is next.
Live today: chess, live and quick, and everything above. The list below is roadmap. None of it is shipped.
More activities
Backgammon and checkers, on the same server-authoritative frame.
More ways to play
Async correspondence play. Tournaments and app-vs-app events. Server-side bot tiers.
More surface
Webhooks. Native SDKs, starting with ParlorKit for Swift, which exists in early form.