Tiniest Cloud

An 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.

list_webhooks

List 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_apps

Show your account's spaces and who belongs to each, with roles. Every team-mode app you own scopes its data by these.

list_spaces

A Tiniest Cloud app's deploy history, newest first, marking which version is live and which are drafts.

list_versions

A 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.

create_app_key

Make 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.

make_app_key

Move 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

Get 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.

preview_app

Put 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.

publish

Map 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_domain

Reads 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_logs

Read 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.

read_app_data

Create 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.

set_webhook

Bring 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.

restore_app

Make 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.

rollback

Convert 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.

modernize_app

Run 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.

run_job

Store 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.

save_webhook_secret

Create 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_job

The 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_icon

The 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_ai_quality

General 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.

set_access

Give 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.

share

Answers 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.

summarize_app_data

Take 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.

unpublish

Change 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.

write_app_data