create_app
ChatGPTCreates a new, empty app and gives back its web address. Nothing is built yet: the app is built by writing its files — get_guidelines with section "all" explains how, public/theme.css and each page are written with write_file (find_photos for photographs, save_image_from_url for the owner's logo), and one deploy publishes it. No AI credits are spent. The connected AI tool builds the app itself: Pabbly Studio's own builder is not used from a connection, so there is no choice of builder to put to the owner. Questions about the app itself are the owner's to answer — what the app is for, its pages, the look, their own words and pictures. Refused when the account has reached its plan's app limit (get_account shows this).
delete_app
ChatGPTPERMANENTLY deletes an app: its code, every version, its whole chat history and its data. This cannot be undone and the app's web address stops working. TWO STEPS: the app must already be switched off with set_app_active(active: false), which takes it offline, frees its plan slot, deletes nothing and can be undone — usually all someone means by being finished with an app. Deleting is for when the owner has clearly asked for the app to be destroyed, and takes the app's exact short name again as confirm.
delete_file
ChatGPTRemoves ONE file from the app. Same rule as write_file: only files the app owns. If another file still refers to it, the build will fail at deploy — remove that reference too. Not live until deploy. Paths are files in the app's own Pabbly Studio source code, exactly as list_files lists them (app files explained: https://docs.pabbly.com/pabbly/doc/pabbly-studio-how-to-view-your-app-s-files-and-attachments-8mxpf).
deploy
ChatGPTPuts the app live at its web address. If files were written with write_file since the last version, it checks them all together, records them as ONE new version and builds it — that is how a direct edit goes live. With nothing new written, it rebuilds the most recent version, which is the move after a rollback or when the live site fell behind a finished build. A new version appears in the app's chat in Pabbly Studio, where the owner and their team read what was done to the app: request and summary are shown there and name the version on its Versions tab; without them the chat lists only the files the version changed.
diff_versions
ChatGPTShows what changed between two versions (numbers from list_versions) — or, without to_version, between a version and the files as they are right now, including edits not deployed yet. Pass a path to compare one file. Use it to answer "what did you change?" and to find exactly what to put back. When the owner refers to an earlier version ("V14", "like it was before", "undo that"), what it held can be read with read_version_file or diff_versions — the owner does not need to repeat it. Paths are files in the app's own Pabbly Studio source code, exactly as list_files lists them (app files explained: https://docs.pabbly.com/pabbly/doc/pabbly-studio-how-to-view-your-app-s-files-and-attachments-8mxpf).
find_photos
ChatGPTFinds a real stock photograph and SAVES it into the app, returning the address to use as an <img> src (/photos/<file>). This is how a photograph gets into an app: an image link typed from memory cannot be checked, and a wrong one shows as an empty box on the page. One subject per call, described exactly: 'blueberry tart on a wooden board', not 'bakery'. Suited to a page that genuinely shows a photograph — a hero, a place, a dish, a product, a listing — not to icons, dashboards, tables or forms, and not to stand in for a named person who does not exist. The owner's own logo or brand images come from save_image_from_url, with a link they give. When nothing matches, no photograph is returned.
get_account
ChatGPTShows this account's plan, how many apps it allows and how many are in use, and how many AI credits are left. Check it if a build was just refused: those are the two limits that stop one.
get_app
ChatGPTEverything about one app: its web address, which version is live, whether it is switched on, whether it is running right now, its custom domain if it has one, whether its colours have been chosen, and its latest build — after deploy, call this to see it land, and if that build failed, lastBuild.error is the reason to fix.
get_app_logs
ChatGPTShows what the live app has printed and any errors it hit while real people were using it — the place to look when a page shows an error or a form does not save. This is the RUNNING app, not the build: a failed build's reason is get_app's lastBuild.error.
get_env
ChatGPTLists the settings the app keeps for outside services — API keys, passwords, account ids — and whether each one is filled in. THE VALUES ARE NEVER SHOWN, not even in part: the answer to "why is my SMS not sending" is that the key is empty, not what the key is. The owner fills them in from the app's Environment tab in Pabbly Studio, and the app picks them up on its next deploy.
get_guidelines
ChatGPTThe rules for editing one app: what it is built with, which files can be changed, how write_file and deploy fit together, and — in full — the checks the platform runs on every file, plus a list of further sections and what each covers (design_system for changing a page, htmx_patterns for adding an interaction). "all" returns the whole rulebook, for building a page from nothing. write_file refuses a file that breaks these rules, so this is normally read before the first write_file on an app.
list_apps
ChatGPTShows every app on this Pabbly Studio account: its name, its web address, whether it is live and whether it is switched on. Each app also has a short name — the first part of its web address — which the other tools use to say which app they mean — so this is where an app someone mentions by name is found.
list_files
ChatGPTLists every file in the app's code. Use it to find your way around before reading anything: files under src/app are the app's own and can be changed; the rest is the platform's shared foundation, which the app does not own and cannot change.
list_versions
ChatGPTThe app's history, newest first: each version's number, what was asked for, which files changed and when. These version numbers are what rollback, read_version_file and diff_versions use. Pass search to find the version whose request mentions a word. When the owner refers to an earlier version ("V14", "like it was before", "undo that"), what it held can be read with read_version_file or diff_versions — the owner does not need to repeat it.
query_app_data
ChatGPTLooks up what the app has collected — sign-ups, orders, bookings, totals over time — by running a read-only query on the app's own database and returning the rows. Nothing can be changed this way: the connection only reads.
read_file
ChatGPTShows the contents of one file, by the exact path from list_files. A very long file is cut short and says where it was cut. The app's .env holds the owner's API keys, so for it only the key names are shown, and whether each is filled in. Paths are files in the app's own Pabbly Studio source code, exactly as list_files lists them (app files explained: https://docs.pabbly.com/pabbly/doc/pabbly-studio-how-to-view-your-app-s-files-and-attachments-8mxpf).
read_version_file
ChatGPTShows one file exactly as it was in an earlier version (a number from list_versions). Without a path, lists the files that version held. It only reads: to bring something back, copy it into the current file with write_file and deploy — the owner's other changes since then stay. rollback is different: it restores the WHOLE app and drops every change made after that version. When the owner refers to an earlier version ("V14", "like it was before", "undo that"), what it held can be read with read_version_file or diff_versions — the owner does not need to repeat it. Paths are files in the app's own Pabbly Studio source code, exactly as list_files lists them (app files explained: https://docs.pabbly.com/pabbly/doc/pabbly-studio-how-to-view-your-app-s-files-and-attachments-8mxpf).
rename_app
ChatGPTChanges the app's display name. Its web address does NOT change — it is the app's address, already in any link or QR code out there, so it never moves.
rollback
ChatGPTRestores an earlier version of the app inside Pabbly Studio and makes it the live version again at the app's own web address. Version numbers come from list_versions. History is not erased — the restored code is recorded as a NEW version on top, so a rollback can itself be rolled back.
save_image_from_url
ChatGPTDownloads ONE image from a public link and saves it into the app, returning the address to use as an <img> src (/photos/<file>). For the OWNER's own pictures — their logo, a brand image, a product shot they host somewhere — from a link the owner gives; an invented link fails. The link is fetched directly over HTTPS from wherever it points — no third-party API is involved — and only a public address is accepted. JPG, PNG, WEBP, GIF or AVIF up to 5 MB; SVG is not accepted (a PNG works instead). A name already used in the app is REPLACED, which is how a logo is updated. Stock photographs come from find_photos.
set_app_active
ChatGPTTurns the app's public site on or off. Switching it off is completely reversible and removes nothing: the code, the data, the custom domain and the certificate all stay, the slot it used on the plan is freed, and switching it back on is instant. This is usually what someone wants when they say they are finished with an app.
set_design
ChatGPTApplies ONLY to an app whose get_app design says its colours are "set" or "NOT SET — call set_design" — apps on an older template, whose theme the platform writes. Where design says "written by the app" or "NOT WRITTEN" — every app created now — this tool refuses, and the colours live in public/theme.css, written with write_file (get_guidelines section "colour"). On an app it applies to: sets the colours, fonts, light or dark mode and overall style. Pabbly Studio turns these into the app's theme — for light and dark mode both — and every part of the app takes its colours from there. Until it is set, such an app shows in a plain default look, its dark-mode switch does nothing and deploy refuses the first version. Only the button colour is required; anything left out is worked out from what is given and adjusted so text stays readable. A palette suits one app and its audience — a habit tracker and a law firm do not share one, and two apps by the same owner should not look alike. It can be set again at any time; the next deploy applies it. Colour values belong in the theme, not in the app's other files (get_guidelines section "colour").
write_file
ChatGPTWrites or replaces ONE file in the app with the full content given. Only files the app owns can be written (get_guidelines lists them; anything under src/app always is) — the platform's shared foundation is refused. The file is checked against the platform's rules before anything is saved; if it breaks one, the write is refused with the reason, so it can be fixed and written again (get_guidelines lists the rules). Nothing is live until deploy, which publishes every file written since the last version in one go. Written to .env, only new key NAMES are added, empty — a value is refused and the owner's saved values are kept; the owner fills them in from the app's Environment tab. Paths are files in the app's own Pabbly Studio source code, exactly as list_files lists them (app files explained: https://docs.pabbly.com/pabbly/doc/pabbly-studio-how-to-view-your-app-s-files-and-attachments-8mxpf).
