Creator Studio

Build with your agent

Bring the UniPlays SDK, templates, and publishing tools into your editor.

Connect your access key

Create an access key in your profile, then add it to your agent configuration.

Configure your client

Add the uniplays entry to mcpServers in your project’s .mcp.json.

.mcp.json

{
  "mcpServers": {
    "uniplays": {
      "type": "http",
      "url": "https://mcp-testnet.uniplays.fun/mcp",
      "headers": {
        "Authorization": "Bearer ${UNIPLAYS_API_KEY}"
      }
    }
  }
}

Set UNIPLAYS_API_KEY in the environment that launches this tool, then restart it.

Restart Claude Code, approve the project’s MCP server when prompted, and run /mcp to check the uniplays connection.

Start the conversation

Give your agent a starting point. It can build, validate, and prepare your game for launch.

Starter prompt

Read uniplays://sdk/client, uniplays://manifest/schema,
and uniplays://runtime/constraints before writing code.

Scaffold an arcade game named Neon Dodge with ticker DODGE.
Download and extract the returned archive. Apply the returned
gameJson to game.json, then build a playable game with saves
and a leaderboard labeled as unverified.

Keep unavailable features optional. Package the bundle,
create an upload, PUT the archive with its Content-Length,
validate with mode: full, and preview it.
Fix errors and show me the preview.

Before preparing a launch, show me the token name, symbol,
description, and social links.
Wait for my review. I will sign the transaction in my wallet.

Game templates

10 templates

vanilla-minimal

Plain HTML and JavaScript with no build step.

arcade

Game loop, cloud saves, and a client leaderboard.

idle-store

Saves, USD-priced store declarations, and holder gates. A purchase settles through the pinned Checkout; a network with no Checkout binding refuses it.

gated

Compare advisory browser gates with access enforced by your own backend.

multiplayer

Server-authoritative play and player JWT verification with a companion Node backend.

match

The staked-match API with a practice fallback. Creating a match needs complete signed terms and a reported result needs the resolver’s signature, both from your own backend.

farm-market

A farming loop with saves, published collectibles and wallet-confirmed trading when the required chain bindings are configured.

crest-club

A token whose trading fee is shared by the holders of three crest types.

hosted-farm

The same loop with a private hosted module: a trusted clock and protected state decide a harvest, and the browser never proves its own score.

prize-draws

Two paid prize draws with a fixed set of prizes, played from the page.

Available tools 35

Read & inspect

environment: Inspect chain configuration, service health, contract verification and hosting availability, and read the launch terms in force and whether your developer accepted them. A person accepts the terms from a wallet session, never a key.
owned_games: Page through the games owned by your developer key’s wallet.
assets: Inspect published collection types, supply, mint history, inventory and holders. Signer, handover and full holder pages require the game owner.
market: Read listings, exact quotes, fills and volume. Creator-share accounting requires the game owner. This tool does not approve or execute a trade.
hosting_inspect: Read an owner-authorized hosting intent and page its ledger. No payment is prepared or executed.
hosting_status: Developer-only deployment health, redacted logs, daily usage, prepaid credit and monthly statements.
hosting_template: Scaffold a private protected-state farming module and versioned backend sidecar.
hosting_validate: Check private source size, digest and configuration without executing uploaded code.
scaffold: Inputs: template, name?, symbol?. Returns an archive, file list, and gameJson. Replace the archive’s game.json with the returned gameJson.
stats: Read player counts, sessions, focused playtime, retention, and purchases for a game and time window. Owners receive full detail; other callers receive public data.
token: Read price, curve progress, graduation, holders, and fees.
versions: Read published versions with hashes, changelog, capabilities, and transaction history. Use a version ID when preparing a rollback.
list_items: Read item definitions and exact prices from the live published manifest. Add or change items in game.json, then validate and publish a new version.
economy: Read the game treasury or one award voucher: the balance, the live split and percentages, the caps in force, the launch limits and the day counters. Every figure carries the block it was computed through.
chance_rounds: Read one chance round or one entry in it: the terms, the pinned key ids, the armed rules hash and the outcome table. It draws, reveals and verifies nothing.
npc_offers: Read one standing treasury bid: its unit price, the day’s remaining units, its expiry and whether it is firm. A read of the desk, never a quote bound to a seller.
draws: Read a game’s paid draws: each draw’s state, exact price, stock and waiting plays, one wallet’s plays, one play with its verification transcript, and the disclosure a player acknowledges first. Only draws the pinned draw factory made are listed, and nothing here plays or refunds.

Build & publish

hosting_manage: Retry a stored private deployment or set an explicitly approved spending limit for an intent you own. Requires publishing scope; it does not fund the account or export player state.
hosting_preview: Execute a paid private deployment with separate preview state and no NFT signing.
hosting_publish: Deploy private bundled JavaScript to an authorized prepaid intent and bind a confirmed matching frontend.
hosting_payment: Prepare an explicitly approved initial $25 credit or manual recharge checkout; confirm only authoritative settlement.
create_upload: Inputs: sizeBytes?, contentType?. Returns uploadId, a signed API url, method PUT, headers, maxBytes and expiry. PUT the archive to that url with the returned headers and a Content-Length equal to its size.
validate: Inputs: uploadId, mode? (static or full), gameId? for updates. Defaults to static validation. Returns jobId, status, errors, warnings, hashes, and review status. Full mode also runs the browser gate.
preview: Inputs: uploadId, gameId? for updates. Preview and publish both need a passing validation in mode full whose browser gate ran. Returns an unlisted preview URL that expires after 24 hours.
publish: Prepare a launch, update, or rollback. devBuyWei sets an optional first purchase and minTokensOut its slippage floor. Returns an unsigned txRequest, versionId, and confirmEndpoint.
confirm_publish: Inputs: original versionId and submitted txHash. The API verifies the owner and receipt before pinning the live version. Retry a pending confirmation with the same pair. Repeats return live while the receipt stands; superseded receipts are refused with 409. No transaction is signed or submitted here.
list_recoverable_publishes: Read up to 20 newest owner launch handles with a recorded txHash and incomplete live-version pinning. Requires publishing scope. Excludes unsigned drafts, updates, rollbacks and completed live games; keep your original handles locally.
configure_economy: Prepare one treasury policy, cap or offer change for the owning wallet. It reads the treasury first and refuses a request above a frozen ceiling rather than letting the chain refuse it. A raise waits out its delay; a cut binds at once.
set_npc_offer: Prepare a standing treasury bid: the price per unit, the units per day, the expiry and how long the bid stays firm. A price above the type’s frozen ceiling, or any change that worsens a firm bid, is refused.
open_chance_round: Prepare a chance round against a table armed at launch. The outcome weights, the payouts and the entry window are checked locally first, and the maximum payout leaves the treasury when the round opens.
checkout_catalog: Read the published catalog, the purchase split the treasury holds and the catalog revision on chain, then prepare the catalog configuration against them. Prices change only through a new published version.
rewards_epoch: Read the reward issuer and guardian, and one epoch at a final block with its budget and windows, then prepare its funding. The funding step needs the issuer signature over the terms.
match_config: Read the match resolver and the window it is valid in, derive a match id from complete terms, or read the terms struct a player must see before joining.
handoff: Prepare a workflow a developer key cannot finish: market_wallet, hosting_export, hosting_account, hosting_secrets, reward_delegation, holder_rewards_launch, launch_terms, draw_create, draw_play or draw_refund. It signs nothing and accepts no terms, takes a secret name and never a secret value, and makes one read, the live manifest for reward_delegation, to refuse a type the hosted key must never mint.
composer_launch: Inspect a composer deployment, prepare an unsigned create or stage, and recover an interrupted composer launch. It never signs, never replaces a publication and never claims wallet-session ownership.

Resources & prompts

uniplays://hosting: Hosting modes, runtime limits, SDK helpers, secure rewards, metering and prepaid billing.
uniplays://sdk/client: Client method signatures and errors.
uniplays://manifest/schema: The game.json schema.
uniplays://runtime/constraints: Sandbox, engine, network, and size requirements.
uniplays://patterns/capabilities: Capability declarations, consent, and graceful fallbacks.
uniplays://patterns/token: Token reads, store declarations, and confirmation patterns.
uniplays://patterns/assets: Published item definitions, wallet-reviewed asset operations and marketplace reads. Writes require supported contract bindings and a wallet session.
uniplays://policy/token: Token launch, fee, supply, and graduation rules.
uniplays://policy/ranking: How play activity, verification, and retention affect ranking.
uniplays://sdk/server: External server SDK guidance. Optional hosted functions use the built @uniplays/sdk/backend helpers; read uniplays://hosting for availability and prepaid billing.
uniplays://developer/workflows: Reading the environment, owned games, assets, market and hosting with the authority each one needs.
uniplays://patterns/treasury: Treasury policy, caps, awards and the standing bids of the item desk.
uniplays://policy/chance: Round rules, the disclosure a player sees before a first entry, and verification.
uniplays://patterns/mobile: What declaring touch promises, and how a game plays well on a phone.
uniplays://patterns/drops: Optional fair drops declared in game.json: drop tables, the seasons a game update must keep, and how a game server records kills and grants each drop once.
uniplays://patterns/draws: Optional paid plays for the game’s own NFTs: the draws block, USD and token pricing, how a result is decided after the play, creating and stocking a draw, and the rule that only a draw the pinned factory made counts.
uniplays://policy/draws: The versioned draws disclosure: every statement, the hash an acknowledgement is recorded against, and what a surface must do with it.
uniplays://patterns/holder-rewards: Paying part of the trading fee to NFT holders: the total fee, the holder part and the weights, what is fixed at launch, what the treasury keeps, and the two-transaction first publish.
uniplays://policy/claw: UPLAY claw price, buyback and platform fee split rules.
uniplays://contracts/errors: Contract errors by name, with when each one happens.
uniplays://examples/{slug}: The selected example’s manifest, instructions, file digests, and archive URL.
uniplays://games/{gameId}/manifest: A private game manifest. Your key must own the game.

Prompts

build-arcade-game: Start a game with a loop, saves, and an unverified leaderboard.
add-leaderboard: Add scores, seasonal rankings, and verification labels.
add-token-store: Declare a store priced in USD and confirm every purchase through the shell.
add-token-gate: Add holder access with a server-side enforcement plan.
convert-to-server-authoritative: Use your own backend or optional UniPlays functions when enabled. Read uniplays://hosting; never authorize hosting payments without the developer’s explicit approval.
add-game-economy: Add a treasury, an item desk or a chance game, with the ceilings frozen at launch read before anything is prepared.

Access keys

Keys are shown once. Give reading tools uniplays:read; publishing tools need uniplays:read + uniplays:publish. Manage or revoke keys in your profile.

Connection problems

A 401 Unauthorized response means the key is missing, expired, or revoked. Check the endpoint and key in your configuration. Your wallet signs launch transactions; an access key cannot sign them.