create_app_key
ChatGPTA key a script or another service sends as a bearer token to read one app's data over HTTP, outside a browser — or with access 'write', also to set and delete entries. It reaches only the app's data API (GET _api/kv/get, list, page, count, sum, group; POST _api/kv/set, delete) and sees what a scheduled job sees: the pool in a shared app, the owner's own data in a private one, the app's team space in team mode. The reply holds the key once; it is stored hashed and cannot be shown again. At most 10 per app. With in_card, nothing is made here: the person presses Create in the card this tool shows, and the key appears there alone, never in the reply.
deploy
ChatGPTDeploy a set of static files to Tiniest Cloud, creating the app if it doesn't exist. Every deploy is a new immutable version and previous versions stay restorable. A new app goes to My Apps, or with space to that space, named with its company part (crm--acme); space does not move an app that exists. With publish: false the version is saved as a draft and the live app does not change. A version whose page code calls tiny.* with no SDK tag is also saved as a draft instead of going live, unless force; the reply says which happened. Apps work here when they use the Tiniest Cloud SDK (/sdk.js) for sign-in and storage; tiny_guide returns its reference. An app that uses localStorage or its own login still deploys, and the reply lists those problems. This server runs on Tiniest Cloud, not on the user's machine, so it cannot read local folders: files carries each file's path and contents. index.html sits at the top level. A project's source instead — a package.json with a build script and nothing built yet — is installed and built on the platform (a few builds a day by plan), then deployed; the reply comes once the build is done, or names the build if it is still running. Text files go as-is, images and other binary as encoding:'base64'. node_modules, .git and dotfiles are not needed. Inline content is limited to 2 MB. In place of files, upload_id names a zipped build of up to 40 MB already sent to a signed upload URL, and deploys that. The Tiniest Cloud web page also accepts a dragged folder of that size. With base_version, the call carries only changes to that version, which must be the live one: files (or the upload) are added or replace the file at the same path, paths in remove are deleted, and every other file carries over. For an app built from source on the platform, the changes apply to its source, which is built again.
get_app_source
ChatGPTThe live version's files with its version number: for an app built from source on the platform, the source it was built from (kind 'source'); otherwise the files it serves (kind 'files'). Every path is listed with its size. Contents come for text files within 100 KB, smallest first; the rest are listed in omitted. With paths, only those files, each whole up to 1 MB in all. Binary files (images, fonts) are listed, never returned.
get_build
ChatGPTAn app's build on the platform — what a deploy of source code starts: whether it is still running, succeeded (and which version it deployed) or failed, with the error and the last lines of the build log. Without build_id, the most recent build.
get_logs
ChatGPTReads an app's backend log, newest first: each recent call to its server code with when it ran, which function, the outcome, how long it took, the error a caller saw and what the code printed. Also says whether this deployment runs backend code, and the plan's limits. Read-only.
get_starter
ChatGPTReturns a starter project set up for Tiniest Cloud, as file paths and contents. 'app' is React, TypeScript, Vite, Tailwind CSS and shadcn/ui, with the SDK tag, its TypeScript types and React hooks already in place. 'site' is Astro and Tailwind CSS, one page per file. The reply also gives the commands that install and build it, the folder the build writes, and the design playbook for that kind of project (the app or website topic of tiny_guide). Nothing is written or created anywhere; the files come back in the reply. Deployed as they are, the files are built on the platform.
list_app_keys
ChatGPTAn app's keys: name, last four characters, read or write, when made and when last used. Never the keys themselves.
list_apps
ChatGPTList the apps in your Tiniest Cloud account — URL, live version, last deploy, version count, data mode — plus any apps shared with you, most recently deployed first. This is the answer to "what apps do I have?" and "what is on Tiniest Cloud?" from the account itself. search keeps apps whose name contains it; space keeps one space's apps. The reply holds up to limit apps (20 unless set) and says how many there are in all.
list_spaces
ChatGPTShow your account's spaces and who belongs to each, with roles. Every team-mode app you own scopes its data by these.
list_versions
ChatGPTA Tiniest Cloud app's deploy history, newest first, marking which version is live and which are drafts.
list_webhooks
ChatGPTAn app's incoming webhooks — each one's URL, where deliveries go, how it checks signatures and whether its signing secret is set — and the most recent deliveries: when, the outcome and HTTP status the sender got, the key a delivery was saved under, any error, and the status of the job it started.
make_app_key
ChatGPTMake a key for one app's data API, as asked for by pressing Create in a Tiniest Cloud card. The reply holds the key once; it is stored hashed and cannot be shown again. At most 10 per app.
modernize_app
ChatGPTConvert a deployed app's code to Tiniest Cloud's architecture: localStorage and calls to the app's own backend (fetch("/api/…"), axios, localhost) become tiny.db so data follows each user's account across devices, the SDK tag is added, any hand-rolled login is replaced with tiny.me()/tiny.login(), and an tiny.rules.json is written if the app stores structured records. It applies when a deploy reported that an app uses localStorage or calls its own backend, or when someone wants an app to work properly / use the real database. The result is a new version and the previous one stays restorable with rollback.
preview_app
ChatGPTGet a one-time URL that opens a Tiniest Cloud app in a browser ALREADY SIGNED IN as the connected account. Apps are gated by a sign-in, so their normal URL shows the login page to anyone not signed in. The link works once and expires in 15 minutes. Without app it opens the dashboard. With preview or a version, it opens the app's preview address instead (<app>--preview), which shows that version, or the newest, to the app's owner and space admins only, using the app's real data; the live app is not changed.
publish
ChatGPTPut a version of an app live: a draft saved with deploy's publish: false, or any older version. Without version, the newest. A version whose code calls tiny.* with no SDK tag is refused, with why, unless force. Visitors see the published version at the app's address; app data is not touched.
read_app_data
ChatGPTRead the data stored inside one of your apps on Tiniest Cloud, so you can answer questions about it — "what tasks are still pending?", "what did people submit to my form?". Returns the app's stored entries as key/value pairs for you to read and summarise. Optionally pass a key prefix (like "task:") to narrow it. Read-only: this cannot change an app's data. You see exactly what you would see by opening the app yourself — in a private-data app that is only your own entries, never another user's.
restore_app
ChatGPTBring a deleted app back, with every version, share and all its data. Works for 30 days after deletion, while the app is still in the recycle bin. Its name stays reserved for that whole window, so a restore cannot fail on a name someone else has taken.
rollback
ChatGPTMake a previous version live again. Only moves a pointer — no files are rewritten and no user data is touched, so it is safe and instantly reversible. A draft that has never been live is refused; publish puts a draft live.
run_function
ChatGPTRun one of the app's backend functions as the owner, with the given input, exactly as tiny.call runs it for a signed-in person: in the owner's data scope, under the app's rules. Returns what it returned or the error it threw, its console output and how long it took. What it writes is written.
run_job
ChatGPTRun a job immediately, outside its schedule, and show what every step produced. It runs the steps saved with set_job, each of a kind set_job's input declares, and nothing else.
save_connection_key
ChatGPTStore the key for a connection an app already declared, as typed into a Tiniest Cloud card. The key is kept encrypted on Tiniest Cloud and replaces any key the connection had; the reply shows only its last characters.
save_webhook_secret
ChatGPTStore the sending service's signing secret for an app's webhook that checks signatures, as typed into a Tiniest Cloud card. The secret is kept encrypted on Tiniest Cloud and replaces any the webhook had; the reply shows only its last characters.
set_access
ChatGPTGeneral access for an app. 'restricted' (default) = only the owner and invited emails can open it. 'link' = anyone with the URL can open it, and anyone who signs in gets their own data as a normal user. Switching back to restricted closes the app again; what visitors saw or copied while it was open stays with them. require_sign_in with 'link' is the third door: anyone may come, but nobody anonymously. The platform enforces it, so the app's own code needs no sign-in gate. company_access with 'restricted' also lets in anyone signed in with a verified address on the company's email domain (the space owner's), as visitors with their own data.
set_ai_quality
ChatGPTThe owner's dial on an app's tiny.ai calls, in three settings named by effect: 'best' (the plan's top model — writing, analysis, anything tricky; uses more of the monthly allowance), 'balanced' (the default — good answers at a sensible cost), 'fastest' (quick, short answers for simple things). It is a CEILING: code that asks for a dearer model is brought down to it, code that asks for a cheaper one is left alone, and code that names no model runs on it. Every app starts on 'balanced'. 'best' is part of the Personal and Team plans: on the Free plan this call is refused with a sentence written for the owner, and the app stays on Balanced.
set_connection
ChatGPTDeclare a third-party API the app may call, so it can use tiny.fetch(name, { path, method, json }) without ever holding the key. A connection reaches ONE host. kind says how the secret is sent: 'bearer' (Authorization: Bearer), 'header' (a header you name), 'query' (a parameter you name), 'basic' (user:pass), or 'none' (no separate secret, or the URL itself is the secret — a Slack webhook URL). A key is never passed through this tool. The connection is declared as a SLOT: the app knows what it needs, and the owner adds the key once, in the box on the card this tool shows or in the app's Connections panel, so it goes from them to Tiniest Cloud and never through the conversation. For a URL that is itself the secret (a Slack or Discord webhook), base_url is its host alone (https://hooks.slack.com) and the owner adds the full URL the same way. A call through an unfilled slot fails with a message naming it. Saving the same name with the same host, kind and header or query name keeps the key it has, and the card offers a box to replace it; anything different replaces the connection and clears its key. public: true lets strangers trigger the connection, such as a Slack webhook behind an open form.
set_data_mode
ChatGPTSet how an app partitions the data it stores on Tiniest Cloud (nothing outside Tiniest Cloud is involved): • 'private' (default) — every person gets their own data. • 'shared' — one pool every user reads and writes. • 'team' — data belongs to a space; Acme's people cannot see Beta's, enforced by the server. Spaces are account-wide: one list for your whole account, used by every team-mode app you own. It suits anything multi-tenant. If the app already has stored data or other users, switching needs confirm: true. The switch hides everything stored under the old mode — nothing is deleted, and switching back restores it.
set_domain
ChatGPTMap a hostname you own (notes.example.com, or an apex like example.com) to an app. Returns the DNS records to add: one pointing the hostname at the platform, one TXT record proving you control the domain. The domain goes live once both are found; calling it again with the same hostname re-checks. Until then the app keeps answering at its platform address. One custom domain per app; the owner takes it off in the app's Custom domain panel. Claiming one needs a paid plan, so on a free space this answers 403 and says so; a domain already live is unaffected.
set_icon
ChatGPTThe app's icon in browser tabs, on phone home screens, in the install prompt and on the Tiniest Cloud dashboard: a glyph from Remix Icon's filled set, drawn in white on a gradient. icon is a Remix Icon name without its -fill or -line suffix, such as 'wallet-3', 'bar-chart-box' or 'question-answer'; an unknown name, or a plain word such as 'quiz' or 'budget', is refused with the closest icons by name and keyword. color is one of rose, red, orange, yellow, green, teal, cyan, blue, indigo, purple or pink, or a hex colour such as '#16a34a', which centres the gradient on that colour's hue; left out, the app keeps the colour it already has on the dashboard. The glyphs come from the copy of the icon set bundled with Tiniest Cloud, and the icon is drawn on Tiniest Cloud's own servers; nothing outside Tiniest Cloud is contacted. An icon the owner chose in the dashboard is kept unless replace is true. The owner can change or reset it on the app's Icon page.
set_job
ChatGPTCreate or replace a scheduled job: a list of steps the platform runs for the app on a schedule, while nobody has it open. Steps are data; run is the one that carries code. Verbs: fetch (through a connection), get/set/delete/list (the app's data), ai (a prompt), judge (typed yes/no, one-of and how-much questions about a value, for an if to rest on), notify (a push notification to the owner, or to everyone on a shared-mode app), if/then/else, stop, and run (a small JS function: export default async (input, tiny) => value, executed in an isolated machine with no network; tiny.db.set/delete QUEUE writes applied after it returns; console output comes back in the trace; paid plans only). Name a step's result with as; use it later in {{ }} templates and if expressions. The schedule is every_minutes OR daily_at + timezone, or neither for a job that runs only when triggered — by a webhook naming it, whose delivery the steps read as event, or on demand. The guide's "Scheduled jobs" section has the full step reference, and run_job runs a job once and returns its trace.
set_space
ChatGPTMove an app into one of your spaces — every member can open it, and a space admin can manage it — or pass space: null to move it back to My Apps. Only the pointer moves: versions, shares, and data are untouched, in both directions. Spaces are created in Tiniest Cloud's dashboard.
set_space_access
ChatGPTFor an app whose data_mode is 'team' — one app serving several spaces, each walled into its own data. 'all' (default) lets every space in the account open it; 'listed' turns everyone away at sign-in except the app's own space and the ones named in spaces. It fits when one customer buys an app the others should not even open. Setting 'listed' needs a paid plan; a list that exists keeps enforcing on any plan.
set_webhook
ChatGPTCreate or update an incoming webhook: an address on the app that another service (Stripe, a form tool, GitHub, Zapier) calls when something happens. Each delivery — JSON, a form or text, up to 256 KB — is saved into the app's data under save_to plus a generated key that sorts by arrival, and/or runs the job named in job, whose steps read it as event. A retried delivery of one event is saved once. verify checks the sender's signature: stripe, github, standard (Standard Webhooks, as Svix-based senders sign), or hmac with verify_header (the header holding an HMAC-SHA256 of the body, as Shopify, Typeform and Razorpay send). The signing secret is not a parameter here: the owner pastes it into the app's Webhooks panel. The reply carries the URL, which contains the hook's secret. Updating a hook keeps its URL and changes only the fields given; fields left out keep their values, and null clears one. In team data mode the app must live in a team space.
share
ChatGPTGive someone access by email. In private mode they get their own separate data; in shared mode they join the common pool. Per-space isolation comes from team mode and the account's spaces, not from sharing.
start_upload
ChatGPTReturns a signed URL that accepts one zip of a built site, up to 40 MB, and the upload_id that names it, for builds too large to pass inline. Creates the app if it doesn't exist, in My Apps or the space named in space, as deploy does; slug in the reply is the name to deploy to. The URL takes a single HTTP PUT of exactly size bytes with Content-Type application/zip, so sending it needs a client that can upload a file, such as a shell. The URL is valid for an hour and the upload for a day. This call deploys nothing: the upload is live only once it is deployed by its upload_id.
summarize_app_data
ChatGPTAnswers how-many and how-much questions about the data an app stores on Tiniest Cloud, WITHOUT reading its records — "how much did I spend on food", "break down my spending by category", "what did each month cost", "how many tasks are still open". sum totals a number, by splits it up, or both. It returns a few numbers instead of every record, so it works the same on an app with 40 entries and one with 40,000.
tiny_guide
ChatGPTReturns the Tiniest Cloud build guide: what an app deployed to Tiniest Cloud needs in order to work. Apps written without it tend to use localStorage and hand-rolled logins, which do not work here. With no arguments: the SDK reference (auth, storage, AI), the storage limits, the data modes, deploying and the platform's constraints, then the names of the guide's other sections. With section, returns that one section: ai, files, rules, fetch (calling other services), jobs, webhooks, functions and the rest. With topic, returns the design guidance for one kind of build: design (principles, directions by industry, checklist), or app, website, dashboard, presentation or form (that playbook, with the directions and the checklist).
unpublish
ChatGPTTake an app offline without deleting it: its address answers that it is not published, and visitors' data calls are refused. Nothing is deleted. Its versions, data, shares, jobs and webhooks stay, and app keys keep working. publish, or a deploy that goes live, brings it back.
write_app_data
ChatGPTChange ONE entry in one of your apps' own storage on Tiniest Cloud — "mark task 2 done", "rename that project". Writes the whole value for a key: the value sent replaces the stored one and is not merged with it. Returns what was there before, so a mistake can be put back. The app's own rules still apply.
