Build AI apps without a backend
Write a web app, call any model through our SDK, and upload it as a zip. Users sign in with RunApps and pay for their own AI usage — no servers or API keys for you to manage.
Free to publish · Users pay for their own usage
Read the full docs →Before you upload
An app gets its slug the moment you create it — no zip needed. Develop on your own machine against that slug; the published app runs on the very same identity.
- 1
Create the app as a draft
Dashboard → Creator → Publish: name and describe it, leave the bundle empty, save. Or let your agent call create_app. A draft is private to you and never reviewed.
- 2
Point your dev server at it
Pass the slug as the SDK's project option. Sign-in from http://localhost works, calls go through the real gateway on your own balance, and files land in the app's real namespace.
- 3
Upload when it's ready
Build, zip, upload to the same app. Slug, files and prompts are already in place, so the code that ran locally is the code that ships.
// The slug from your draft app — the same one the published
// app will have, so nothing changes at upload time.
const client = new RunApps({ project: "my-tool" });
const resp = await client.chat.create({
model: "Claude Sonnet 4.6",
messages: [{ role: "user", content: "Hello!" }],
// While developing, send a prompt inline; ship it as
// .private/prompts/outline.md and use { id: "outline" } later.
prompt: import.meta.env.DEV
? { template: "You write outlines in five acts." }
: { id: "outline" },
});Let your AI agent do it
Claude Code, Codex, Cursor or any MCP client can create the app, upload the bundle and publish it for you. One sentence to the agent; one click from you.
- 1
Paste this to your agent
It reads the setup page, asks RunApps for a key, and shows you a link.
- 2
Approve in the browser
You see the agent's name and what it wants to do; untick what you do not want. No password is typed for it, ever.
- 3
It builds, uploads, publishes
Through the RunApps MCP server: create_app, upload_bundle, update_app, get_review. Its key is listed under API Keys and can be revoked any time.
Read https://www.runapps.ai/agent/setup.md
and connect to RunApps.Install the skill so the agent knows the platform: npx skills add runapps/skills
Publish in three steps
- 1
Call AI with the SDK
Add one script tag or npm i @runappsai/sdk. Users sign in with RunApps, so there is no API key in your code.
- 2
Upload a zip
Upload your built static files. The app goes live on its own runapps.dev link.
- 3
List it
Share the link, or submit the app for review to be listed in the library.
npm i @runappsai/sdk<script src="https://www.runapps.ai/sdk/latest.js"></script>
<script>
const client = new RunApps();
const resp = await client.chat.create({
model: "Claude Sonnet 4.6",
messages: [{ role: "user", content: "Hello!" }],
});
console.log(resp.choices[0].message.content);
</script>Keep your prompts private
Anything in your frontend code can be read in the browser. Ship prompts as files inside your zip and list them in bundle.json: RunApps never serves that file or anything it names, and your app calls a prompt by id — for chat, and for image, video and speech models alike.
- 1
Write the prompt file
Write one Markdown file per prompt anywhere in your project, e.g. prompts/outline.md, and map an id to it in bundle.json at the zip root; a short prompt can be written straight into bundle.json as { "text": "…" }. Mark values your app fills in at call time as {{genre}}.
- 2
Call it by name
Pass the prompt's name and values as the prompt option of chat.create, as in the code. The server adds the prompt as the system message; only the name goes over the network. Image, video and speech calls take the same { id, vars } in place of their prompt text (or the spoken input): the filled-in prompt becomes the text.
- 3
Zip it with your build
Copy bundle.json and the prompt files into your build output and zip it. The publish page lists the prompts it found. A file named after its id under .private/prompts/ (such as .private/prompts/outline.md) needs no entry; set prompts_dir in bundle.json to use another folder, which is then withheld whole.
While developing locally
Your own dev server has no uploaded bundle yet, so send the text along as prompt.template. The server accepts that only from the app's creator, and import.meta.env.DEV keeps it out of the production build.
The model is told to keep the prompt confidential, and any reply that repeats it word for word is withheld. A determined user may still get a model to paraphrase it, so never put keys or passwords in a prompt.
{
"prompts": {
"outline": "prompts/outline.md",
"rewrite": "prompts/rewrite.md",
"greeting": { "text": "You are the concierge of {{app}}. Be brief." }
}
}You are the outline writer for this studio.
Every story has five acts, with a twist in act four.
Genre: {{genre}}async function privatePrompt(id, vars) {
const prompt = { id, vars };
// Your dev server only: send the text along. Vite drops
// this branch (and the file) from production builds.
if (import.meta.env.DEV) {
prompt.template = (await import(
`../prompts/${id}.md?raw`)).default;
}
return prompt;
}
const resp = await client.chat.create({
model: "Claude Sonnet 4.6",
prompt: await privatePrompt("outline", { genre: "mystery" }),
messages: [{ role: "user", content: idea }],
});npm run build
cp -r bundle.json prompts dist/
cd dist && zip -r ../app.zip .Your users' data on every device
Keep your app's data in IndexedDB as you always have. RunApps Sync carries it to every device the user signs in on: writes go up a few seconds after they commit, other devices' changes come down when the page is opened, focused or back online, and the badge shows the state. On by default, no code to add.
- 1
Use IndexedDB as usual
Directly or through Dexie, idb or idb-keyval. Create the client before the first indexedDB.open; on a new device that first open waits for the user's data, so the first read already sees it. Use keys you choose (crypto.randomUUID()), not autoIncrement, so two devices never hand out the same id.
- 2
React to remote changes
When another device's changes are applied, the db:change event names the database, store and keys. Re-read that store and redraw. Every committed put, add, delete, clear and cursor edit syncs, with Dates, Maps, Sets, binary and Blobs intact.
- 3
Leave out what is local
Caches, decoded media and anything large or rebuildable: exclude a store ('app/cache') or a whole database ('cache'), or turn Sync off with sync: false. Synced data lives in the user's file space for your app and counts as their storage.
Two devices editing different fields of one record keep both edits; the same field, the later write wins. Another user signing in on the same browser starts from their own data. Data syncs only for signed-in users; writes made before sign-in are queued and sent afterwards.
// Create the client before the first indexedDB.open.
const client = new RunApps();
const req = indexedDB.open("todo", 1);
req.onupgradeneeded = () =>
req.result.createObjectStore("items", { keyPath: "id" });
const db = await new Promise((ok) => (req.onsuccess = () => ok(req.result)));
// Write as usual; use your own keys, not autoIncrement.
db.transaction("items", "readwrite").objectStore("items")
.put({ id: crypto.randomUUID(), text: "buy milk", done: false });
// Another device changed something: re-read that store.
client.events.on("db:change", ({ store }) => render(store));new RunApps({ sync: false }); // off
new RunApps({ sync: { exclude: ["app/cache"] } }); // keep a store local
client.sync.status(); // idle | syncing | offline | error, pending
await client.sync.now();Share data with every user of your app
Templates, skills, catalogues, anything you want to keep updating without shipping a new zip. Put it in your app's public folder: anyone can read it, only you can write it.
- 1
Write under _public/
The folder is part of your own files for the app, so publishing is an ordinary file write. Its structure is yours; most apps keep an index.json next to the files.
- 2
Anyone reads it, no token
client.shared lists and reads the folder, signed in or not. An overwrite shows on the next read. Reads are free.
- 3
Copies belong to the user
client.shared.copy puts a file into the signed-in user's own files, billed to them as a write. Their copy stays as it is when you update the original.
// Anyone, signed in or not.
const { templates } = await client.shared.json("templates/index.json");
const cover = client.shared.url("templates/a/cover.jpg"); // <img src>, no token
// Copy into the signed-in user's own files.
await client.shared.copy("templates/a/cover.jpg", "my/cover.jpg");
// You, the app's creator.
if (await client.shared.canPublish()) {
await client.shared.put("templates/a/cover.jpg", blob);
await client.shared.put("templates/index.json", JSON.stringify(index));
}Ready to build?
Publish your first app, or create an API key and start calling models.
Publish an appFree to publish · Users pay for their own usage