You don't need to be a programmer to benefit from apps, and if you are one, you don't need to be a Scryboard expert to build something people will actually use. Here's the whole picture, from why this exists to the exact steps to ship one.
Get the Scryboard App Runner
The free desktop program that runs apps on your own computer, with no terminal. You need it for any app that calls an outside service, uses a package, or reads a file — and it's the easiest way to run one you've installed from the Marketplace. Windows.
The Scryboard Ecosystem
Scryboard listens to your table and turns what actually happens there — the transcript, your prep notes, the rules that come up, the fights that break out — into structured, tagged data: beats, characters, factions, locations, items, rules, history. Scryboard's own dashboard is just one thing built on top of that data.
The App API opens that same data up to anyone. Instead of waiting for Scryboard to build the exact tool you want, you (or a player, or a third-party developer) can write a small program — an app — that reads exactly the slice of it you find valuable and turns it into something useful: a spell-usage histogram, a running NPC roster, a character stat card, a story timeline.
Apps never run on Scryboard's servers. Browser apps run inside the campaign page, and everything else runs on your own computer (or a player's) through the App Runner. Each one reads only what its access token allows. Beyond display cards drawn in Scryboard's own style, an app can write back what its manifest declares: new canon for the DM to verify, canon imported from a wiki, details such as portraits attached to existing entries, a player's own character data, images, and encounters or XP awards for the DM to confirm. Every write an app makes is listed on its Marketplace page before anyone installs it and checked when it's submitted. Build one for yourself, or publish it to the Marketplace for everyone else running the same kind of table.
Before You Start
Prerequisites: underneath everything below is a plain REST API (JSON
over HTTPS), so any language works, and you can run an app yourself —
self-hosted, on your own machine or server — without ever touching the
Marketplace. The example apps on the Downloads list are
Node.js scripts written this way — Node.js 18+ (for the built-in fetch) is the
only thing you need installed to run or adapt them. If you've just installed
Node.js and a command like node --version still says it's not recognized,
open a new terminal window — Windows in particular won't pick up a PATH
change in a window that was already open.
If you want to list on the Marketplace instead, what a buyer's install
actually downloads depends on your app's runtime: a browser_sandboxed
app is one code file, submitted as a .zip with its scryboard.json —
no git clone needed, and there's a ready-to-submit starter template on
the Downloads list at the top of the App API docs page. A node_cli app —
anything calling an outside API, using a package, or needing a secret — ships
as a small .zip (your code plus a scryboard.json manifest) and runs
through the Scryboard App Runner,
a small desktop app, rather than the buyer's browser. See
Choosing a runtime below and the
manifest reference before you start writing code — the
runtime you pick determines what you can build with.
Trying your app on your own campaign before (or without) publishing:
upload it as a personal app. Sign in, open /agents, and under Your
Own Apps click Upload your app (.zip). It gets the same automatic
checks a Marketplace submission gets, but nobody reviews it and nobody else
can see it. Then pick one of your campaigns under Connect to: and click
Connect. A browser_sandboxed app then runs whenever you have that
campaign's page open; a node_cli app offers Get Runner link, which
hands its token to the App Runner. To try a change, click Replace code
on the app and pick the new .zip. This is the test loop for
browser_sandboxed apps, which can't run anywhere outside Scryboard.
Testing without touching production: there's currently no separate staging deployment of Scryboard — the only live environment is production. Rather than pointing a new app under development at your real campaign with a real token, use the mock server first: it's a zero-dependency local stand-in for this entire API, backed by fixture data, with a preview page so you can see your pushed widgets rendered without writing anything to a real database. Do one final pass against a real token before publishing, since the mock is a fixture and can drift from actual behavior over time.
That's the short version — every endpoint, every payload shape, and the full read/write contract lives at /docs/agent-api.
Step-by-Step Workflow
The whole path from a blank script to a listed Marketplace app, thirteen steps across four phases. Each card is clickable where there's somewhere real to go.
Phase 1 — Set up
Install Node.js
18+, from nodejs.org. If a command still isn't recognized right after installing, open a new terminal window.
2In ScryboardRead the API docs
The full technical reference — public, no account needed.
3Scryboard downloadGrab starter files
Mock server + a starter template for each runtime, from that same page.
Phase 2 — Build & test offline
Pick a runtime & write your app
Sandboxed (one file, browser-only) or Node (packages, secrets, outside APIs). See the manifest reference for scryboard.json.
Run the mock server
node mock-server.mjs → localhost:4747
Run your app
Point SCRY_BASE_URL at the mock, use a mock_* token.
Preview the widget
Open localhost:4747 in a browser.
Phase 3 — Test for real
Get a real token
DM: campaign page → Advanced (developer) → App Access Tokens. Player: Your Apps.
Run against production
Same script, real scry_... token.
Confirm the widget
Check your campaign, session, or player page.
Only building this for your own table? You're already done — stop after Phase 3. Publishing to the Marketplace is entirely optional and only matters once someone else wants to install it; it doesn't gate whether you can run your own app.
Phase 4 — Publish to Marketplace
Submit your app
Upload the .zip (code + scryboard.json); describe placement and setup.
Wait for review
Approved, or sent back with a specific reason.
Live — buyers install it
Installing mints a token. Sandboxed runs in their browser; Node runs through the Scryboard App Runner, one click either way.
Getting Noticed & Pricing
A clear, honest description matters more than anything else — say exactly what your app does and what a DM or player will actually see. People are more likely to install something they can picture using right away.
Once people have installed your app, they can leave a star rating and a written review — this is the main way other users judge whether something is worth trying, so it's worth asking early users for honest feedback. A small number of apps are periodically featured at the top of the Marketplace page — there's no submission process for that, it's simply apps worth highlighting.
Anyone can submit an app to the Marketplace; each one is reviewed before it goes live. Personal apps you only run yourself aren't reviewed.
Apps can be free, a one-time purchase, or a monthly subscription ($0.99–$500), and one purchase covers every campaign the buyer runs. To charge, first finish the one-time Stripe payout setup on Developer & Sales, then set a price from your listing's own page. Scryboard keeps 15% of the sale, Stripe's processing fee comes off separately, and the rest is paid out to you. If a sale is refunded, your share of it is taken back in proportion. Most first apps start free.