How Player Two works

The store and the launchpad

Player Two is a game store and a launchpad in one room.

• The store holds finished games and demos, free or paid. Buy a game and it’s yours; add a free one to your library.
• The launchpad holds games still being made, raising money from players. Backers put money in, Player Two holds it, and the developer is paid stage by stage as they prove the work is done. Once the game is out, its backers get a part of each sale, as the developer set.

Anyone with an account can put a game on Player Two, and it goes live the moment it’s submitted. Payments are real: USDC on Base.

Three ideas

• Money waits for proofRaised money stays with Player Two until each stage of work is shown to be done.
• Backers have a sayBackers can object to proof, and vote on what happens when something goes wrong.
• One set of rulesThe same fees and rules for every game: 10% of a sale, 5% of each stage paid out.

Signing in

Sign in with email, Google, Discord or X. Privy, the company that runs our sign-in, sets up your balance the first time you sign in. You can look around and play free web games without an account; you need one to buy, back, wishlist, add games to your library or submit a game.

Your public name starts as a made-up one, like Hitbox Lawyer or Slightly Used Kazoo, never your email or your Google name. Change it in your profile: 2 to 32 letters, numbers and spaces. A few names, like Admin, Support and Player Two, are kept for us.

Your balance

Your balance is held in USDC, a digital dollar (one USDC is meant to be worth one US dollar), on Base, the network it moves on. You pay from it, and everything paid to you lands in it. There’s nothing to install and no recovery phrase to keep. It lives with Privy, so it stays yours even if you leave Player Two. It shows at the foot of your profile.

Adding funds

Add funds, at the foot of your profile, opens Privy’s top-up window. Pay by card or bank, or transfer funds in from another account or app: whatever you use arrives as USDC on Base. Player Two pays the network fees. A card or bank provider may charge its own fee; Player Two adds none.

Paying

Every payment goes through the same steps, and the button you pressed says which one it’s on:

1. 01Set upPlayer Two makes the payment: what it’s for, how much, where it goes.
2. 02Check your balanceShort of funds? You’re offered a top-up first.
3. 03ApproveYou approve the transfer from your balance, within 30 minutes.
4. 04Confirmed on BaseIt counts once the transfer is confirmed: from your balance, the right amount, to Player Two.

Nothing leaves your balance until you approve. Our server also watches the treasury on Base, so a transfer that arrives without being confirmed the usual way is still matched to its payment: from the same balance, for the same amount, within three days.

Browsing

• Tabs: All games, Store, Launchpad, Library and Wishlist.
• Search by name, studio or genre, and narrow by stage, genre, price and where a game plays.
• Arrows under the cards step through the ring, with where you are in it.
• An empty tab, or a search with no match, says so and offers somewhere to go: free games, the store, or submitting a game.

Cards and the big screen

Each card wears its studio’s name at the top. Its foot shows where the game stands: a beam for a raise, a ring of arcs while it’s being built, and a pulse of daily players once it’s out. Owned games say so on the card. The player count is how many people have the game in their library.

The big screen shows the chosen game’s name, its raise if it has one, a heart for your wishlist, and its buttons: Back this game for a raise, Buy for a game on sale, Play free for a free one.

Your profile

Press your pixel creature at the top of the room. The panel shows your player pass and your figures, your backer passes, your library, your wishlist, your studio if you have one, and your balance with Add funds and Claim. Open it out into your full profile page for everything, including your notices and payouts, the games you’ve hidden, and your name.

Buying

Press Buy on a game’s page and approve the payment. Once it’s confirmed, the game is in your library. If you hold the game’s backer pass, it’s already yours. A second purchase of a game you already own is sent straight back.

Free games

Press Add to library on a free game’s page (sign in first). Free web games also play without an account.

Your library

Your library holds the games you bought, the free games you added and the games that came with a backer pass. Games you backed show there too, so you can follow them. Hide any game with the eye on its cover in your profile; it stays yours, and your full profile page lists hidden games so you can show them again.

Your wishlist

The heart on any game puts it on your wishlist (sign in first); press it again to take it off. The number beside a heart is how many players have that game on their wishlist. The room’s Wishlist tab shows yours.

Playing

• Web games play on Player Two, in its player, each from its own address on playertwo.cc, which keeps it apart from your account. Its saves follow you to any device. A free one is anyone’s to play.
• A paid web game plays from a play link made for each of its owners, which lasts 6 hours. The page asks for a fresh link each time you press Play.
• Games played on their developer’s own site are the developer’s responsibility: Player Two doesn’t host them and can’t control who reaches them.

Downloads

Developers can upload builds for Windows, Mac and Linux, as a demo and as a full version.

Each download link is personal and expires after 10 minutes; the game’s page makes a new one when you need it. Every new upload is reviewed by Player Two before players can get it.

The Player Two app for Mac and Windows is the easy way: it lists every game you own and every demo, installs one with a press, picks up a stopped download where it left off, offers a developer’s new version as an update, and starts the game with Play. It fetches its own fresh links as it goes.

The terms of a raise

Once a raise opens, its terms are fixed: the developer can still change how the page looks and reads, but never the terms backers put money in on.

Backing

On a raise’s page, Your cut works out what a stake could make as copies sell. Choose a stake, review it (what it makes if the game sells well, breaks even, or sells nothing), tick the box that says you could lose what you put in, and confirm.

• A stake can be anything from the smallest stake up to what the raise still needs. When less than the smallest stake is left, the last backer puts in exactly what’s left.
• Each stake gets the next backer number for that game, starting at 1.
• A stake of at least the planned price brings a backer pass, and the game: it goes in your library, and it’s yours free on launch day.
• Developers can’t back, object to or vote on their own games.

Funded, or closed short

A raise closes the moment it reaches its goal. It’s funded: the first stage is under way, and each stage’s deadline counts from that day. If the closing date comes first, every backer is refunded in full. Money that arrives after a raise has closed or filled is sent straight back.

The risk

Proof and objections

When a stage is done, the developer posts its proof from their studio: a link backers can open and check, like a public build or a video, with a note if they like. Backers are told, and have 3 days to object. With no objection, the stage is paid out to the developer, less Player Two’s 5%, and the next stage begins.

Any backer can object: under the proof, press This doesn’t meet the objective and say, in a sentence or more, what doesn’t match. The first objection opens a vote.

Votes

A vote lasts 5 days. Every backer can vote, and change their vote while it’s open. Votes count by the dollars each backer has in the game. On an objection, the choice is to pay the stage out or to refund what’s left. The side with more dollars behind it wins; a tie goes the game’s way. While backers vote on a stage’s proof, that proof can’t change.

Too few votes

A vote counts only if backers holding at least 20% of the money take part. If too few vote, Player Two reviews the stage and decides: pay it, give more time, or refund what’s left.

Missed deadlines

When a stage’s deadline passes without proof, a vote opens by itself, and backers choose between giving the developer 30 more days and refunding what’s left. If the developer posts proof while that vote is open, the vote ends and the proof gets its own 3 days for objections.

Refunds

A refund sends back everything that hasn’t been paid out, to every backer in proportion to their stake. Stages already paid out stay paid. After the last stage is paid, the raise is complete.

The split of a sale

Player Two keeps 10% of every sale. For a game that raised money, its backers share the percentage its developer set when raising, split among them by stake. The developer gets the rest. Here is a $15 sale with a 40% backers’ share:

The raise fee

Player Two keeps 5% of each stage of a raise as it’s paid out to the developer. A $10,000 raise whose first stage is worth 30% pays $3,000 for that stage: $150 to Player Two, $2,850 to the developer. Refunds carry no fee.

Earnings and claims

Sales build up what each backer and each studio is owed. Either claims it once it comes to $1 or more:

• Backers claim from the foot of their profile. It’s paid to their Player Two balance.
• Developers claim their studio’s earnings from their studio. It’s paid to the studio’s payout address.

A backer’s share of a sale is their part of all the money backed. With a 40% share, a backer holding 1% of the raise earns $0.06 from each $15 sale.

Payouts

A payout is money leaving Player Two’s treasury: a stage paid to a developer, a refund, or a claim. For now, every payout is reviewed and approved by a Player Two admin before it’s sent.

1. 01QueuedA stage clears, a refund is due, or someone claims.
2. 02ReviewedA Player Two admin checks the amount, where it goes, and why.
3. 03SentThe treasury sends it as USDC on Base.
4. 04ConfirmedConfirmed on Base. The person paid gets a notice.

A studio’s payouts go to its payout address, which is the developer’s own Player Two balance unless they change it. When a studio changes its payout address, its payouts are held for 2 days and the developer is told, so a stolen session can’t quietly send a studio’s money elsewhere. No payout goes to a studio until its developer’s identity check is approved.

Money sent back

Two kinds of payment are sent straight back to the balance they came from: money that reaches a raise after it has closed or filled, and a second purchase of a game the player already owns. The player is told why.

The treasury

Raised money and sales wait in Player Two’s treasury, an account protected by Privy’s policies:

• Our server alone can send only USDC on Base, and only up to a cap on each transfer.
• A larger payout needs an admin’s own key as well as the server’s.
• What the server sends by itself is also limited each day.
• Changing the treasury or its rules takes both keys.

Backer passes

A backer pass is a collectible card that comes with a stake of at least the game’s planned price. It carries the backer’s number for that game and brings the game itself: it’s in their library, and theirs free on launch day. Its rarity comes from the stake:

1. CommonThe planned price
2. Rare$100 or more
3. Epic$250 or more
4. Legendary$1,000 or more
5. Mythic$2,500 or more
6. Divine$10,000 or more

Each stake counts on its own, and its rarity is fixed when it’s made: two $100 stakes bring two Rare passes. When a game will be free at launch, every stake brings a pass. Every pass has its own page whose link shows the card, to share anywhere. Passes are records kept by Player Two.

The player pass

Every player has a player pass. It’s made like a backer pass, with the player’s creature and name, and the points they’ve earned where a stake would be. Its rarity climbs with points, each rarity ten times the last.

Listing a game

Press the plus in the room, or go to Submit a game, and sign in. First choose a path: put the game in the store, or raise for it. Then fill in the game, its look, where it plays, its price or its raise, the plan (for a raise), and you. The game’s page builds itself beside the form as you type, and the game goes live the moment you finish.

• Needed: a name, a tagline, what it is in a paragraph, at least one genre, where it plays, a trailer, its key art (one square picture, 2400 by 2400 at best, with what matters in the middle: its card shows the middle two-thirds, its page’s first screen is made 3D from it, and the store’s wide places show a band of it), and your studio’s name. A game for the store also needs a way to play it; a raise needs its stages.
• Price: free, or up to $500 in USDC. A game that didn’t raise money pays you 90% of every sale.
• Its look: the launch trailer plays in the form as it will on your page. Up to four gameplay videos can follow it, and the screenshots after them, each in the order you drag them into. Your name’s lettering is one of the templates, a typeface from Google Fonts’ library, or a font of your own (WOFF2, WOFF, TTF or OTF, up to 2 MB; only one you’re allowed to use on the web). Player Two keeps the font’s files and serves them itself, and the font goes with the game if it’s taken down.
• Features: up to six lines of what players get. Each is a card on your page, with a photo of its own if you give it one, or as words in your game’s colour.
• Where it plays: a link to your own site, or a web build hosted by Player Two.

Your studio

Your studio is made with your first game (or started on its own), and your studio is where you run everything. It has three columns under one bar:

• The bar: your studio’s name (its own sections, below), one search, and Money, Analytics (all your games together), Help and Docs.
• On the left, your games, each with its cover, where it stands (for sale, free, private, its day, raising), and a badge when something waits on you (a stage’s proof, a vote, and its comments new for you). Under the game that is open, its sections, Updates with how many comments are new for you (“3 new”) and Builds with its live build’s version: Grow (Overview, Updates, Analytics, and Its raise for a raise), Ship (Builds, Downloads, Playtests), Sell (Price and sales, Codes and keys, Add-ons), Run (Rooms, Trophies and boards, Saves and Connect) and Settings (Its page, Leave the store). The games of the other studios whose team you are on are listed under each studio’s name. Last, Put a new game up.
• In the middle, one section at a time. Overview is the game’s home: its key art with where it stands, its name in its lettering, its build (“Build 1.3.2 live”), downloads, rooms and trial in one line, and four buttons (Post an update, Push a build, Edit its page, Open it); then four figures (players in it now, with the new players of its last 30 days; sales in the last 7 days against the 7 before, or new players for a free game; wishlists, with this week’s; and the share of its reviews that recommend it), Next up (what waits on you: a post going up later, its comments new for you (“3 new comments on “Patch 1.3””, with Read them), a build out to its testers (“Build 1.4.0 is with your 3 testers”, with Make it live), players asking to playtest it, a stage’s proof, a vote, its release day, a download Player Two is looking at, your identity check for a raise) and its last 30 days, day by day, with its price, trial and sale. Every other section has the game folded to one strip at the top, with the same four buttons.
• On the right, the game right now: sold today (or new players today), its rooms open, its live build’s version and since when, with Push a build, and New comments: the comments on its updates new for you (below, Posting updates), to Reply to or Take it down; a comment’s post name opens that post’s comments in Updates, and Mark all read marks every post’s read. With none new it says All caught up, and shows the latest.
• Your studio’s own sections (press its name): Profile (its name, what you are, a note to players, your sign-off, your links, its logo and GitHub; it shows on every one of your games’ pages), Identity (for a raise), Messages, Money (what your studio is owed from sales, the Claim button and your payout address), Team, Bundles, Webhooks, Agents, Teams you’re on and All games (searched, narrowed by where each stands, and put in order).
• Search (⌘K on a Mac, Ctrl K elsewhere, or the search in the bar): type a game, a setting or something to do, like “impact sale”, “trial” or “keys”. It lists what to do (“Start a sale on Impact”), each setting of each game with where it lives (“Sell › Price and sales”), your other games and your studio’s sections, and says what is new (“Read 3 new comments on Impact”, a game’s live build’s version, “Make build 1.4.0 of Impact live” while its testers have it); the arrows move, Enter opens it, Escape closes. Something that can’t be done to a game says why, and opens where to change that (a private game can’t be on sale: release it first).
• Each place has its own address, to keep or send: /studio#game-<slug> for a game’s overview, /studio#game-<slug>/price for one of its sections (updates, analytics, raise, builds, downloads, playtests, price, codes, addons, rooms, trophies, connect, page, leave), and /studio#studio/money for one of your studio’s. On a phone the left column is a menu at the top (your games and the open one’s sections) and the right one comes under the section.

Playtests and release days

A store game can stay private while you test it, or be listed with the day it comes out: choose in the form’s last step (When it goes live), or later in your studio’s Release, until it is out. Once it is out, it stays out (archiving takes it out of the store).

• Private: only you, your team, your testers and Player Two’s admins can open its page and play it. It is in no list, search, sitemap or the room, search engines are told not to index its page, and its page draws no share card.
• On a day, up to 365 days ahead: in the lists with its day, its page anyone’s with Wishlist in place of Play and a countdown (you can turn it off); a paid game takes pre-orders. Only you, your team and your testers play it until then. At its moment it is out by itself, and its wishlisters and your followers are told.
• Playtesters, in your studio on a game not out yet: invite a player by their handle (a tester at once; up to 1,000 testers a game, 200 invites a day), say yes or no to players who ask from a coming game’s page (each with a few words, ten asks a day at most, and their hours, games, trophies and latest reviews beside it; a no reads to them as asked, and they can’t ask again), or take one off. Testers play it free and in test mode (p2.test: what they earn is kept apart), with rooms, voice, saves and trophies working, and get it in the Player Two app. Once it is out, they get the builds you send to testers first (pushing a build).
• Anyone with the link: turn on Anyone with the link can playtest it in Playtesters, and copy the link. As with a shared document, whoever opens it sees the game’s page (a private one’s too), and once signed in is one of its testers from then on, without the link: free and as a test, a paid game too, marked by link in your list. Signed out, they see the page, and Playtest asks them to sign in first (a playtest needs an account, for its saves, rooms and test mode); the link holds through the sign-in. The game stays out of every list either way.
• The link’s rules: off until you turn it on, and only for a game not out yet. Its secret comes after a # in the address, which browsers never send to a server or to another site, and the page takes it off its address at once; the browser keeps it 30 days, sent only with that game’s own calls. Turn it off and nobody comes in by it, and every tester who came by it is taken off at once; turn it on again and it is the same link. Reset the link for a new one: the old one stops at once, everywhere, and the testers who came by it go too. The testers you invited or said yes to always stay, and so does a link tester you invite by handle. A tester you take off while the link is on stays off (the link won’t bring them back), and a player you said no to isn’t let in by it. Twenty wrong links an hour from one address, then every try from it waits for the hour. Keeping it private again from a day, or giving it a day, leaves the link as it is; once the game is out, the link turns off by itself and the testers who came by it go (the ones you invited stay, for testers-first builds). You or a developer on your team can change it, sixty times an hour; your agent too (below).

Editing a game

Every part of a game’s page can change: open it from your studio, or press Edit page on the game’s page. Once a raise is open, its goal, smallest stake, backers’ share, length, planned price and stages stay as backers agreed to them.

Posting updates

News, patch notes, a date: an update goes first in the Updates of the game’s page. Its team posts it (the studio’s owner, or a member whose role is developer or admin) from the card first in those Updates, which only the team sees, from Post an update in the studio, or through an agent.

• Its title: 2 to 80 characters. Its words: up to 10,000 characters, the marks counted; 2 at least, unless it has a picture or a video.
• Formatting, from the row of marks over the words or typed as Markdown: bold (**bold**, ⌘B or Ctrl+B), italic (*italic* or _italic_, ⌘I), a heading (a line starting with ##; # and ### make the same one size), a bulleted list (lines starting with - or *), a numbered list (1.), a quote (>) and links ([words](https://...), ⌘K, or an address written out). Enter on a list’s line starts its next item, and on an empty one ends the list. Preview shows it as players will see it. Lists don’t nest, and a backslash keeps a mark as itself (\*).
• What isn’t formatting: HTML shows as the characters you typed; a link goes only to an http or https address (anything else, javascript: included, shows as its words), opens in a new tab and is marked nofollow; pictures come only as attachments, never by Markdown (![...](...) is a link to it).
• Pictures and a video: up to 4 pictures, or a video and 3 pictures, chosen with the picture button, dropped onto the composer or pasted. Pictures are PNG, JPEG or WebP up to 12 MB, a video MP4, WebM or MOV up to 80 MB (a video your browser can’t play is refused, since players’ can’t either). Each shows how far its upload has got and can be taken out; the post waits until they are all up. Uploads count toward everyone’s daily limit of 300 files, 40 of them videos.
• How it shows: in the feed, its first picture (or its video, without sound, playing while the pointer is on it or once pressed; never by itself if a player asks for less motion) stands where other posts show one of the game’s screenshots, with +2 and so on for the rest; pressed, the whole post opens over the page with its pictures large. Long words are cut at about nine lines in the feed, with Read more. A post without pictures shows one of the game’s screenshots, as before.
• Who hears of it: its backers, the players who have it in their library, who wishlisted it and who follow your studio, once each, in their notices (and by email and push, unless they turned game updates off), as plain words: the first 240 characters, the marks taken out. A private game’s update is for its page alone. Twenty updates a day a player.
• In other languages: players read it in their own language, translated as reviews and comments are (they can show the original), a paragraph or a list’s item at a time, with its marks kept. A piece whose translation would change where a link goes, and one over 4,000 characters, shows as you wrote it. Your team always sees it as written.
• Posting later: Post later, beside Post it, takes a day and a time in your own time zone (its name and the same moment in UTC show beside it), 5 minutes to 90 days ahead; the button then says Schedule. Until its time only your team sees it, first in the Updates after the composer, marked Scheduled for its time, with Edit (its words, pictures and time), Post now and Delete; visitors, the store, the feeds and the API’s public reads don’t see it, and nobody is told. At its time it goes up as if posted then (its date is that moment) and its audience is told then, once, as for any post (none for a private game). Player Two’s clock puts it up within a couple of minutes of its time, and any visit to the game’s page or read of the game puts up one whose time has come. Deleting one before its time sends nothing. Up to 20 wait at once a game; each counts toward the twenty a day when it is made. An edit before it is up isn’t marked Edited, and it can be pinned once it is up.
• Editing one: under each of the game’s posts its team (whoever may post) sees Edit, Pin and Delete; nobody else does. Edit opens the post in the same composer, in place: its title, words and pictures or video, by the same rules and limits as posting, its attachments still only files uploaded for this game. Saving tells nobody again (no notice, email or push); the notices and emails it already sent keep its first words. The post keeps its place and its date, with Edited after the date (the time it was edited when you point at it), and its translations are made again from the new words. The posts Player Two writes about the game (a release such as “Out now”, a raise’s news, a stage, a vote) are edited the same way, from the same Edit: their title, words and pictures or video, by the same rules. Each keeps its kind (a release still says Release), its date and its place, with Edited after the date, and the edit is in the audit log with what it said before. They can’t be deleted, and Player Two’s admins who aren’t on the team can’t edit them (nor any of the team’s posts). A picture or video taken out leaves Player Two’s file store a day later, unless another of the game’s posts shows it.
• Pinning one: Pin puts a post first in the game’s Updates, before the newest, with Pinned on it for everyone. One post a game is pinned: pinning another unpins the one before, and Unpin puts it back in its place by date. Any post can be pinned, Player Two’s own too (an “Out now”, say); pinning tells nobody.
• Deleting one: Delete asks first (“Delete it? Yes, delete / Cancel”). Then the post is gone from the game’s page, the feeds, the studio, the weekly email and the API, and unpinned; it can’t be brought back. The notices it sent are taken out of players’ notices, so an email or push not sent yet never goes; an email already sent stays sent (its button opens the game’s Updates). Its pictures and video leave the file store a day later, unless another of the game’s posts shows them. Only the updates a team wrote can be deleted. Player Two’s admins can delete one too, after a report, say.
• Comments: players comment on every update once it is up (not on one waiting to go up). Its card says how many (“12 comments”, or Comment); pressed, the whole post opens with its comments under its words, oldest first and the newest last, and a box to write in. Any signed-in player who isn’t banned may comment, 1 to 2,000 characters in plain words, and reply to a comment (the reply says whom it answers); a player blocked by your studio’s owner (or blocking them), or by the one they reply to, can’t. Comments and Discussion answers share one limit: 60 an hour a player. Your team’s comments are marked Developer. Your team (and Player Two’s admins) can take any comment down (kept out of sight, in the audit log) and Lock comments on a post (the ones there stay; no more); a player can take their own down and report anyone else’s (Spam, Abuse, Off-topic: into Player Two’s moderation, as Discussion’s are). Comments are translated for each reader, as Discussion is. The post’s author (its studio’s owner for Player Two’s own posts) gets one notice a post that counts up (“5 new comments on…”) while it is unread, emailed and pushed when it first comes; a commenter gets a notice for each reply to them. A post deleted takes its comments and those notices with it. A post’s comments are its own: they aren’t topics in the game’s Discussion. From an agent: list_comments, hide_comment and lock_comments (GET and PATCH /api/v1/agent/games/<slug>/posts/<id>/comments, DELETE .../comments/<comment>), with mark_comments_read (POST /api/v1/agent/games/<slug>/comments/read) to mark them read for the key’s player once they have seen them; agents don’t comment, players do.
• In your studio: each game’s Grow › Updates has the composer at the top, then lists its updates (narrowed to All, Scheduled, Yours, Player Two’s or With new comments): every post still up, the ones waiting to go up first (marked Scheduled for their time), then the pinned one, then the newest, each with its kind, its day, its title and first line, its first picture or its video’s still, Edited and Pinned, and how many comments, gold with how many are new for you (“5 comments · 3 new”). Each has what its page’s own row has: Edit (the same composer, in place), Pin or Unpin, Delete (asking first), Post now for one waiting, and its comments opened under it, to take one down or Lock comments. Player Two’s own posts are listed too (“By Player Two”), with Edit and Pin and no Delete. The latest five show, the rest behind Show all; one posted from Post an update is listed at once. The signed-in list (GET /api/v1/games/<slug>/posts, and the agent’s list_updates) says each post’s comments, how many are new for whoever asks, and whether they are locked.
• New comments: Player Two keeps, for each of a game’s team (its studio’s owner and the members who said yes), what they have read of each post’s comments. A comment is new for you until you read it: opening a post’s comments in your studio’s Updates, from its live column (a comment’s post name), or on the game’s page signed in, marks that post’s read; answering one from the live column marks it and the ones before it on its post; Mark all read marks every post’s. Your own comments and replies are never new for you; a comment taken down isn’t new for anyone; a teammate’s comment is new for you as a player’s is, and what you read stays yours (your teammates’ stay new for them). A post you never opened has all its comments new; a post deleted, or waiting to go up, has none. Player Two’s admins who aren’t on the team have nothing kept. Signed in: POST /api/v1/games/<slug>/comments/read with { post } (its id) or nothing for every post, and until (milliseconds) to read only up to a moment; a post’s comments (GET .../posts/<id>/comments) say team, how many are new and which (each comment’s new), without marking them. Reads: 300 an hour a player.
• Every edit, pin and delete is recorded in Player Two’s audit log, with who did it (and which agent key), and what the post said before. Edits, pins and deletes: 120 an hour a player.
• Updates posted before 2026-11-07, and the ones Player Two writes itself (a release, a stage paid, a vote), are plain words until they are edited; an edit saves them as Markdown, as every post written since.
• From an agent: upload_media with game set to the game’s slug for each picture or video (an update takes only files uploaded for that game, from its page, its studio or that way: any other address is refused), then post_update with the slug, title, body in Markdown and media, the addresses in order. list_updates lists the game’s posts with their ids and kinds (devlog: the team’s own), editable (every post) and deletable (a devlog); edit_update with an id changes the title, body or media sent, of any of the game’s posts, Player Two’s own too (its kind kept) (what is left out stays; media is the whole new list); pin_update pins or unpins one (pinned: false); delete_update deletes one. post_update with at (milliseconds, or an ISO time with its zone such as 2026-11-08T18:00:00Z) posts it later; list_updates gives its scheduled time; edit_update with at moves it, with now: true posts it now. The agent API: POST /api/v1/agent/media with game, then POST /api/v1/agent/games/<slug>/posts; GET there lists them; PATCH /api/v1/agent/games/<slug>/posts/<id> with title, body, media or pinned changes one (and at or now one waiting to go up), and DELETE there deletes it. Signed in, the same calls are at /api/v1/games/<slug>/posts and /posts/<id>. A Player Two post is 409 to delete; an address not uploaded for the game is 422; another game’s post, or one deleted, is 404.

Identity checks

Only developers who raise money are checked. Before a raise can take any, and before any of its stages is paid out, the developer photographs an official ID and takes a selfie with Didit, our identity partner, from their studio. Didit checks the document is real and the selfie matches it, in seconds; Player Two keeps only the name on the ID and the country that issued it. A check Didit can’t decide is reviewed by a person. Developers who only sell their games or give them away are never asked.

Raising

• Set the goal, the smallest stake, how many days it runs, the backers’ share, the planned price, and the stages: what each will show, its share of the money, and when it’s due, counted from the day the raise is funded.
• Post proof for each stage from your studio. Without an objection in 3 days, the stage is paid out, less 5%, once an admin has checked the payout.
• Once the raise is funded, you can put the game on sale: set its price in your studio. Its backers share every sale from then on.
• Post an update from your studio or the game’s page to tell backers how it’s going. It shows on the game’s page and reaches backers as a notice (updates).

Builds and downloads

• A web build: a .zip of your export’s folder with index.html at the top (up to 100 MB, and up to 300 MB and 3,000 files once unpacked), or one .html file; or, up to 5 GB, the folder pushed with one command. It plays at its own address, <your-game>.playertwo.cc, with no code changes, and can’t reach anything else on the platform. If the game costs money, only its owners can open it. Hosting says what hosting here gives, next to playing from your own site, and how to push a build.
• Trophies, leaderboards, stats, cloud saves and presence: for a game Player Two hosts (a web build or downloads), through one script tag. See the game SDK. A game played on its own site gets them too, in Player Two’s player, with a signed identity for its own servers: see Player Two Connect.
• Downloads: upload Windows, Mac and Linux builds, as a demo and as a full version: a .zip or .tar.gz of the game’s folder (the Player Two app unpacks it and starts the file you name as its launch file), or an installer (.exe, .msi, .dmg, .pkg) that players run themselves. Every new upload is reviewed by Player Two before players can get it, and a new version reaches players’ apps as an update.

Through your agent

Your own AI agent can submit your games for you, for the store or as a raise, upload their pictures, trailers and web builds, and keep their pages up to date. Make it a key in your studio, under Agents; the key is shown once.

• MCP, for Claude, Cursor and other agents that use tools: the server is https://playertwo.lol/api/mcp, with the header Authorization: Bearer and your key, or with no key, signing in when the app asks (Signing in an app); its public tools need neither (For any agent). Its tools are get_submission_guide, check_game, upload_media, upload_web_build, submit_game, update_game, get_game, my_studio, and for a hosted game’s trophies and leaderboards list_trophies, define_trophy, list_boards and define_board, for a web game’s builds list_builds, make_build_live (roll back, or forward) and name_build (its version: the rule), for what it sells list_products and define_product, playtest_link for a game’s playtest link (on, off or reset, as its studio’s Playtesters has it), post_update for an update on a game’s page (its rules; its pictures and video from upload_media with game) and list_updates, edit_update, pin_update and delete_update after, list_comments, hide_comment, lock_comments and mark_comments_read for their comments (which are new for you, and marking them read), and get_rooms: a game’s multiplayer rooms open now and how its players’ connections were over the last minute (the figures), read-only.
• The agent API, for scripts: GET /api/v1/agent/guide explains every field and the rules; POST /api/v1/agent/games submits a game (with publish: false it waits in your studio as a draft; with release it is kept private for your testers, or listed with the day it comes out); PUT /api/v1/agent/games/<slug>/release and /testers change that and look after its playtesters, and PUT /api/v1/agent/games/<slug>/testers/link with { "on": true }, false or { "reset": true } its playtest link; PATCH /api/v1/agent/games/<slug> changes one; POST /api/v1/agent/media and /api/v1/agent/builds take files by https address; GET /api/v1/agent/games/<slug>/web/builds lists a web game’s builds, and POST there with a build’s key (and a note, why) rolls back to it; GET /api/v1/agent/games/<slug>/rooms reads its rooms now and their connections, as get_rooms does; POST /api/v1/agent/games/<slug>/posts posts an update on its page (its rules), as post_update does, GET there lists its posts, and PATCH and DELETE /api/v1/agent/games/<slug>/posts/<id> edit, pin or delete one.
• The API spec: /openapi.json, OpenAPI 3.1, has every call of the agent API, the game SDK and the public reads, with the draft’s every field, its type and its limits. Tools that read OpenAPI can make a client from it.
• How to play, for agents: in the form’s Where it plays step (or agentNotes in the draft), your game’s controls and goals. Players never see them; every game page has a hidden section for agents that visit it (a player’s assistant, a playtester) with them, where to play, whether a guest can, and how to report a bug.
• Reading Player Two as an agent, no key needed: /llms.txt says what Player Two is, lists every game with its page, and leads to the rest; /llms-full.txt is all of it in one file. Every page of the help, the docs and the rules, and every game’s page, is also Markdown at its address with .md after it (/help.md, /docs/sdk.md, /game/<slug>.md), made from the page itself; each page names its Markdown with <link rel="alternate" type="text/markdown"> and carries schema.org JSON-LD (the game, its trailers and price; the help’s questions; the SDK). /robots.txt lets every crawler and AI agent read the public pages, scripts included (only the signed-in pages and the API but for its reads of games are out), and says Content-Signal: search=yes, ai-input=yes, ai-train=yes; /sitemap.xml lists every public page with when it last changed.
• A key can only submit and edit your games. It can’t pay or claim money, change your account or payout address, or take a game down.
• A raise your agent submits is live at once and takes no money until you check your identity in your studio. An agent can’t do that step.
• Revoke a key in your studio at any time; it stops working at once.
• Found by name: the server is lol.playertwo/mcp in the official MCP Registry, and describes itself at /.well-known/mcp.json and /api/mcp/server-card (its card, listed in /.well-known/ai-catalog.json). The SDK, the starter, examples and these docs in Markdown are open at github.com/TheDudeCommits/playertwo-sdk; on npm, playertwo-sdk and create-playertwo-game.

For any agent, no key

Any AI agent can ask Player Two about its games and its docs through the same MCP server, https://playertwo.lol/api/mcp, with no key and no sign-in: a player’s assistant answering what to play, a developer’s deciding where to put their game. These tools only read, and only what the site shows everyone: never an unlisted, archived, private or taken-down game.

• search_games: games by words (every word must be in a game’s name, tagline, description, studio, genres, modes or features), genre, platform, price (free, paid or any), multiplayer (by a game’s genres and modes, or its own servers), kind (store or raise), in an order, limit 1 to 50 (20 if left out) and offset for the next page. Each game with its slug, name, tagline, studio, genres, modes, platforms, price, whether it is free, a sale, a free trial, whether it plays with others, where it plays, its players and reviews, and its page.
• list_games: every game in the store, the same filters, in Player Two’s order (featured: featured first, then the most played), popular, new or playing (most playing now).
• get_game_facts: one game by its slug, with what its page tells agents (what it is, its price, where to play it and whether a guest can, how to play it, whether it is multiplayer, the Player Two services it has, how to report a bug) and its five latest updates.
• get_sdk_docs: a part of these docs in Markdown, as the pages say it today: topic as a page and part (/docs/sdk#rooms), a part’s id (rooms-sync) or a few words (leaderboards, push, fees). Left out, every topic there is. A part is cut at 40,000 characters, with its link for the rest.
• where_to_publish: what Player Two offers a game’s developer, each fact with its link: what it keeps of sales (10%), of in-game purchases (20%) and of each stage of a raise (5%), the ways in, and everything a game gets.
• get_submission_guide and check_game: the fields of a game’s page and a draft checked, as for a key.

In Claude Code: claude mcp add --transport http player-two https://playertwo.lol/api/mcp. tools/list names every tool to anyone, the studio’s too, so a client knows what signing in adds.

Signing in an app

An MCP client that signs in (Claude’s and ChatGPT’s connectors, Claude Code, Cursor, VS Code) needs no key: add https://playertwo.lol/api/mcp, and the first time it calls one of your studio’s tools, Player Two answers that it needs you, the app sends you to playertwo.lol/oauth/authorize, you sign in, see what it will and won’t be able to do, and allow it or not. Allowed, it can do what an agent key does, and no more. It is listed in your studio, under Agents, as “Connected by signing in” with where it is from, and Revoke disconnects it at once. A key keeps working beside it.

• How it is found: a studio tool called without a working key or sign-in is answered 401 with WWW-Authenticate: Bearer … resource_metadata="https://playertwo.lol/.well-known/oauth-protected-resource/api/mcp", scope="studio" (RFC 9728); that names Player Two as the authorization server, whose endpoints are at /.well-known/oauth-authorization-server (RFC 8414).
• Apps: an app registers itself at POST /api/oauth/register (RFC 7591, with redirect_uris and a client_name), or uses a Client ID Metadata Document: its client_id is the https address of a JSON document naming that same client_id and its redirect_uris, read when it asks. Public clients only (token_endpoint_auth_method none): no secret. A redirect address is https, http only to this computer (127.0.0.1, [::1] or localhost, on any port), or an app’s own scheme, never with a #; one to ten of them.
• The code: response_type=code with PKCE (code_challenge_method=S256) always, the redirect_uri exactly as registered, scope studio (the only one), resource if sent https://playertwo.lol/api/mcp. The app gets back its state, the code and iss (RFC 9207); a code works once, for ten minutes, and one shown twice disconnects the app it was made for.
• Tokens (POST /api/oauth/token, a form or JSON): an access token (p2_oauth_…, sent as Authorization: Bearer) for an hour, and a refresh token for 60 days, made new at every refresh (the old one stops). POST /api/oauth/revoke with a token disconnects its app (RFC 7009). An access token works on the agent API too, as a key does.
• Its errors, as OAuth says them (error and error_description): invalid_request (no PKCE, a missing value), unsupported_response_type, invalid_scope, invalid_target (another resource), access_denied (you didn’t allow it), invalid_grant (a code used, run out, for another app or redirect, a verifier that doesn’t match; a refresh token used, revoked or run out), unsupported_grant_type, invalid_redirect_uri and invalid_client_metadata (registering), slow_down (429, too many). An app or a redirect address that doesn’t check out is shown on the page and sent nowhere.
• Its limits: up to 20 apps connected at once (a 21st disconnects the oldest); registering 30 an hour, tokens 300 an hour and revoking 120 an hour from one address; answering an app 60 times an hour.

MCP limits and errors

• Protocol versions: the stateless 2026-07-28 (each request’s version in its _meta, with MCP-Protocol-Version, Mcp-Method and, for a tool, Mcp-Name saying the same; server/discover), and 2025-11-25, 2025-06-18, 2025-03-26 and 2024-11-05 through initialize.
• The public tools: 600 calls an hour from one address, together; past that, a refusal with status 429 until the hour turns.
• A studio’s tools, each player: post_update 20 a day; edit_update, pin_update and delete_update 120 an hour; make_build_live and name_build 120 an hour; define_product 120 an hour; hide_comment and lock_comments 300 an hour; mark_comments_read 300 an hour. Past one, a refusal with status 429.
• What each tool does, in its annotations: read-only, or changing things (destructive: overwrites or takes away; idempotent: the same call again changes nothing more), and whether it reaches past your studio (open world: a public page, players told, a file fetched from an address).

Taking a game down

You can take your game down from your studio while no backer’s money is riding on it. If it has backers’ money in it, ask us, and we settle with the backers first.

A player who browses and plays

1. Arrives in the room

   Turns the ring, switches between the store and the launchpad, searches by genre.

2. Opens a game

   Watches the trailer, reads what it is and who made it.

3. Signs in

   With email, Google, Discord or X. Their balance is set up on the spot.

4. Gets the game

   Adds a free game to their library, or presses Buy, tops up if short, and approves the payment.

5. Plays

   A web game right there (a paid one from a play link that lasts 6 hours), or a download for Windows, Mac or Linux where there is one.

6. Keeps a collection

   Wishlists games for later, hides the ones they’re done with, and watches their player pass climb with every game.

A backer who follows a raise to the end

1. Finds a raise

   On the Launchpad tab. Reads the plan, the stages and the terms on the game’s page.

2. Backs it

   Chooses a stake in Your cut, reviews it, ticks the box, confirms and approves. Gets the next backer number, and a pass if the stake is at least the planned price.

3. Waits for the goal

   The raise fills and is funded, and the first stage starts. Or it closes short, and the backer is refunded in full.

4. Checks each stage

   Gets a notice when proof is posted, opens the link, and has 3 days to object if it doesn’t match.

5. Votes when asked

   On an objection or a missed deadline: 5 days, counted by dollars. If too few backers vote, Player Two decides.

6. Sees it through

   Stage after stage is paid out, until the game is made. Or backers vote to stop, and what’s left comes back.

7. Launch day

   With a pass, the game is already theirs. From now on, every sale adds their share to what they’re owed.

8. Claims

   From $1, at the foot of their profile. An admin checks it, and it lands in their balance.

A developer who raises, proves and gets paid

1. Submits the game

   Chooses to raise. Sets the goal, the smallest stake, the days, the backers’ share, the planned price and the stages. The page goes live.

2. Verifies their identity

   A photo of an official ID and a selfie, with Didit. Then the raise can take money.

3. Brings backers in

   Shares the page and posts updates. The raise fills and is funded; stage 1 is under way.

4. Posts proof

   From their studio, a link backers can check. After 3 days with no objection, the stage is paid out, less 5%, once an admin has approved the payout.

5. Answers to backers

   An objection, or a missed deadline, goes to a vote. Posting proof during a missed-deadline vote ends it.

6. Launches

   Sets a price in their studio once the raise is funded, and uploads builds; downloads are reviewed before players get them.

7. Gets paid

   Stage payouts as each stage clears, and the studio’s share of every sale, claimed from $1 to the payout address.

How Player Two’s admins review and moderate

1. Review identity checks

   The ones Didit can’t decide, before a raise can take money.

2. Review every payout

   Stage payouts, refunds and claims wait for an admin, who checks the amount, where it’s going and why, then sends it or cancels it. A payout over the server’s cap is signed with the admin’s own key as well. A failed payout can be tried again.

3. Review new downloads

   Every new upload is checked before players can get it.

4. Decide stages too few voted on

   Pay the stage, give more time, or refund what’s left.

5. Work through reports

   Each report arrives with its reason, any note and when it came in. The admin checks the game, then dismisses the report, warns the developer, or takes the game down.

6. Take a review's picture or clip down

   On the game’s page, under a review’s pictures and clip, an admin sees Take the clip down (or the picture, or Take a picture or the clip down to choose one), may write why (it isn’t needed) and presses Take it down. The review keeps its words and stars; the file leaves Player Two’s public store for its private one, so its address stops working (and it can be put back by hand); it leaves the review, its writer’s box and Shared by players; its writer is told in their notices, with the reason if one was given; and the log keeps who, any reason and the file’s address. Sending the review again with it never brings it back. 60 an hour an admin; signed in, DELETE /api/v1/reviews/<id>/media with { url, reason }.

7. Settle with backers

   When a game with backers’ money in it comes down, refund what hasn’t been paid out.

8. Ban when needed

   An account that breaks the rules badly, or again and again, can be banned.

9. Leave a record

   Every admin action is written to a log.