- Brand
- Exepad
- Category
- Developer Tools
- Primary Subcategory
- AI App & Website Builders
Integration details
Description
Exepad turns a conversation into a working web app that you own. Ask the assistant to create an app or to change one you already have. It reads the app's source in your Exepad account and writes its changes there. Exepad saves every change as a new revision, builds it, and reports compiler errors so the assistant can fix them. You see a private preview of each build in the conversation or through a link to Exepad. The assistant can check a preview for console errors, exceptions and failed requests, and the page's screenshot appears wherever the conversation shows Exepad's card. An app can keep its data in its own database, store files, run background work and scheduled jobs, and call AI models for chat, images, speech and search. The assistant looks up what your app can use, declares it, and can read how its background work ran. It can read Exepad's recipes and reference text for AI, voice, agents, workflows, files, email and realtime. You can create an Agent project with a signed-in assistant that keeps each user's conversation separate. Agent creation depends on the account's eligibility. All my apps includes Agent projects this connection supports when you approve, plus projects this connection creates. Older Agent projects that cannot be connected remain editable in Studio. Projects created later outside this connection are not added automatically. You can choose a logo, image, font or audio file on an Exepad upload page for the app to use. The assistant receives the destination and file metadata, not your local filename or file bytes. These source assets become publicly readable after you separately approve a publish, even if the app requires sign-in. When the app is ready, the assistant prepares a publish and you approve it in Exepad. Nothing goes live until you do. You can also see an app's release history and rename it. Unpublishing an app, archiving it or turning a one-page site into an app with data is each confirmed in Exepad. For people who want to build and run their own web apps, such as trackers, booking pages, dashboards and small business tools, without setting up hosting. Limitations: an Exepad account is required; every Exepad plan can connect. What an app can use depends on its owner's Exepad plan. The assistant works only with the apps you choose when you connect and the apps it creates. Apps built in Exepad's own workspace can be viewed but not edited. Package dependencies cannot be changed in this version.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- AI App & Website Builders
- Secondary Subcategories
- None listed
- Brand
- Exepad
- Access
- Account required
- First tracked
- 2026-11-20
- Tool count
- 32
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen Exepad suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for Exepad
Get updates when Exepad’s Discoverability Score or category rank changes.
Competing in ChatGPT AI App & Website Builders
View Category32 tools agents can invoke
Request archiving an app, for the user to confirm in Exepad: once confirmed, it is removed from their apps and its private preview stops working, permanently. This call only records the request and answers a link: the app is archived when the user confirms there by typing the app's address. A published app is refused ARCHIVE_BLOCKED_BY_RELEASE until it is unpublished (unpublish_app).
archive_app
Request taking an app offline, for the user to confirm in Exepad: once confirmed, it stops answering at its public address and its connected domains; its build, its data and its preview are kept, and it can be published again. This call only records the request and answers a link: the app goes offline when the user confirms there. An app with nothing live is refused NOT_PUBLISHED unless Exepad finds a publish of it still under way or an earlier unpublish of it unfinished.
unpublish_app
Build an app's source, at its current revision or the one you name, into a private preview: the same clean, model-free build Exepad runs for every app (install, generate, type-check, bundle), then a deploy to a preview no one but the owner can open. Once a build reaches its deploy, the preview's database gets the revision's schema, migrations and sample data, even if a later step fails, and a build that succeeds replaces what the app's private preview shows; the published app and its database are never touched. It answers at once with an operation, whose progress get_operation reports: each get_operation call waits up to about 45 seconds for the build to end, so a build usually takes one or two calls, the answer carries retry_after_seconds while the build runs, and a failed build's answer carries its diagnostics. One build of an app runs at a time, and at most 2 of an account's apps build at once, counting its builds from the Studio and from assistants together: BUILD_IN_PROGRESS with an operation_id names this app's running build; without one, the account's other builds are running, or this app is busy in Exepad itself (a build or publish from the Studio, or an earlier build whose deploy has not finished), and the same call is refused until that has ended. An older revision holding a migration the current one has changed or removed is refused REVISION_SUPERSEDED, which names the current revision. When Exepad's build machines are busy, a build waits in line as queued. Each build is charged to the owner's Exepad wallet when it ends, at 0.5 US cents per minute of build time, counted by the second, when it succeeds, fails on the app's own code (kind app) or is cancelled once its build machine is running; a platform failure (kind platform), and a build cancelled or refused before its machine ran, are not charged. A build needs funds in the account's wallet to start (INSUFFICIENT_BALANCE). Repeating the call with the same idempotency_key and arguments on this connection within 7 days returns the same operation; a call with a new key starts another build. A deploy that is stuck keeps the app's builds refused BUILD_IN_PROGRESS until Exepad clears it. While a platform update is in progress, Exepad starts no new build: PLATFORM_MAINTENANCE, with retry_after_seconds and the operation_id of the build that did not start, which is cancelled and not charged; the same call can succeed once the update has finished. A preview differs from what a publish puts live: rows from seeds/ are sample rows that exist only in the preview, since publishing never reads seeds/ and the published app starts without them; schedules run only in the published app; and the owner sets up the app's administrator in Exepad (App admin › Settings › Set up app administrator) separately for the preview and the published app. An app account's password has no reset in the app: the owner sets a new one in Exepad (App admin › Users), if the owner's account has that tab. Once published, a page that shows data without sign-in shows it to anyone with the app's address.
build_preview
Stop a build that build_preview started, if it has not reached its deploy step: it ends cancelled and builds nothing. Once its build machine is running, the time that machine ran is charged to the owner's wallet; a build cancelled before then is not charged. A build that is deploying or has ended is refused OPERATION_NOT_CANCELLABLE. Cancelling a cancelled build answers it again. A build past cancelling is read instead, which can write Exepad's record of it, as get_operation's description states.
cancel_operation
Change an app's source as one new revision, all or nothing: add, replace, delete or edit files. base_revision_id must be the app's current revision (from list_files, or the revision the last write returned): revisions are immutable, and if anything was written since, the call is refused REVISION_CONFLICT with the current revision and nothing is written. edit replaces old_text, which must occur exactly once in the file, with new_text. Only authored files can be written: package files are read-only in this phase, platform and generated files are never part of the source, and an applied migration never changes, except back to exactly what was applied. Limits (Exepad's own policy): one call carries 1 to 20 changes (INVALID_ARGUMENTS otherwise) and at most 256 KiB of text (content, old_text and new_text together; LIMIT_EXCEEDED past it); a file is at most 64 KiB after an add, replace or edit (FILE_TOO_LARGE); and an app holds at most 300 files, 2 MiB of text and 5 MiB of binaries (LIMIT_EXCEEDED). Binary assets under public/ take encoding base64 on add or replace; their leading bytes match their extension. The encoded content counts toward the call limit and decoded bytes toward the file limit. An edit of a binary path, encoded text or unencoded binary is refused INVALID_ARGUMENTS. A call cut off at the caller's output limit never reaches Exepad, so nothing of it is written; a call of a few files and well under 30 KB of text stays clear of that. Repeating the call with the same idempotency_key and arguments returns the first result. A call that changes exepad.jsonc also answers manifest_issues: Exepad's advisory reading of the new text under this app's lanes, listing what a build of it is likely to refuse and any schedule path a publish refuses; the build's own check decides, and the write is made whatever it lists.
apply_changes
For the preview panel: the state of an app's preview (ready, building, failed or none), the build it concerns and its revision number, and a failed build's diagnostics. Without operation_id it reads the app's latest build; a named build the preview no longer shows answers the app's own state. This call can also write to Exepad's record of a build. While a build runs, calls save its progress. When it is the first to see that a build has ended, it records the outcome; until that is recorded, Exepad counts the build as still running, for this app and for the account's limit on builds at once. A build's deploy records the end of a build that reaches it. One that ends before then waits for a call like this, for the app's page in Exepad while that page follows the build, or for Exepad's scheduled jobs, normally 30 to 45 minutes after the build was requested. In rare cases a call also marks as failed a build that never reached Exepad's builder within two minutes, or one a restart interrupted, and cleans up the machine it left behind. If a success's own record was lost, a call records it, and the preview then shows that build, the one a publish can use. Recording success also saves pending name, derived-address and card work. This call runs none of that work. Exepad's deploy and Studio paths can run it; scheduled jobs try pending work on their next run, normally within 15 minutes, and retry failed attempts. A delayed or failed capture can leave the card waiting longer.
get_preview_state
Create a new Exepad app for the user, connected to this assistant. Its source starts as revision 1 of Exepad's starter template for the profile named; nothing is built or published. kind defaults to app; agent creates an Agent project and requires fullstack. AGENT_UNAVAILABLE means this account cannot create Agent projects. The agents-assistant item in read_reference describes their files and behavior. profile is the user's choice between a one-page site (static) and an app with data (fullstack): it fixes the starter template, and a one-page site can later become an app with data, never the other way. Revisions are immutable: every write makes a new one, and apply_changes needs the current revision as base_revision_id (this result names revision 1). Repeating the call with the same idempotency_key and arguments on this connection within 7 days returns the same app, never a second one; a call with a new key creates another app. The user's plan limits how many apps they have (PLAN_LIMIT_TOTAL_APPS). get_authoring_guide returns Exepad's reference for an app's files. name is kept as given, without leading or trailing spaces: Exepad shows it, derives the app's public address from it, and writes it into revision 1's exepad.jsonc as app.name, which the build writes into the page title. A name the user typed is the app's name exactly as typed, which app.name, the page title and the header carry; the starter's header shows a placeholder name until src/App.tsx is rewritten. description stays in Exepad as what the user asked for: revision 1 has no app.description, the one plain sentence in exepad.jsonc that the build writes into the page's description, which search results and shared links show. Revision 1's identity (src/theme.css: the accent, typefaces and corner radii; src/fonts.ts: the typefaces it imports) and its screens are placeholders, rewritten for every app: screens are composed from src/ui.tsx and coloured through src/theme.css, so a screen written before the identity is designed against the placeholder, and a build fails with template_placeholder while src/App.tsx still shows the starter's placeholder screen. Exepad sends no email for an app: an app with data sends it through the owner's own email-sending account, from a sender domain verified there, with that account's key in a secret setting the owner adds in Exepad, and a one-page site sends none, so an app asked to send email sends none until the owner has that account.
create_app
Show the user Exepad's card for an app's private preview: the app's latest build, or the build you name. The card shows the build's state and a way to open the preview; where the preview cannot be framed in the conversation, it shows the latest screenshot and a link that opens the preview in Exepad. Without arguments it shows the app of this connection built most recently. The preview is the user's alone: this tool returns its state, not what it shows (inspect_preview opens a page of it in Exepad's browser). It answers whether the preview is ready, still building, failed or has nothing to show yet, and, unless there is nothing to show, the app's page in Exepad (open_url), which opens the preview for the owner once signed in on a host with no card. It never publishes the app. This call can also write to Exepad's record of a build. While a build runs, calls save its progress. When it is the first to see that a build has ended, it records the outcome; until that is recorded, Exepad counts the build as still running, for this app and for the account's limit on builds at once. A build's deploy records the end of a build that reaches it. One that ends before then waits for a call like this, for the app's page in Exepad while that page follows the build, or for Exepad's scheduled jobs, normally 30 to 45 minutes after the build was requested. In rare cases a call also marks as failed a build that never reached Exepad's builder within two minutes, or one a restart interrupted, and cleans up the machine it left behind. If a success's own record was lost, a call records it, and the preview then shows that build, the one a publish can use. Recording success also saves pending name, derived-address and card work. This call runs none of that work. Exepad's deploy and Studio paths can run it; scheduled jobs try pending work on their next run, normally within 15 minutes, and retry failed attempts. A delayed or failed capture can leave the card waiting longer.
open_preview
Open one path of an app's private preview in Exepad's browser, as a visitor who is not signed in or, with as, as a test account Exepad adds to the preview, and return a screenshot with the page's HTTP status, the path it ended on, its console messages, uncaught exceptions and failed requests (a failed image request is a broken image URL). It inspects the latest successful build, or the succeeded build you name while the preview still shows it. An inspection reports the page it ends on; a page no inspection has ended on is unchecked. A page that throws while it loads renders blank however correct its code is, and only an inspection of its path shows that, so a page a build added or changed is unchecked until an inspection opens it. The page runs as it would for that visitor or account, so whatever the app's own code does when the page loads happens (such as saving data in the preview's database or requesting other sites on the internet). With steps, clicks, fills, waits and text checks run on the page before the screenshot. They run the app's real code, so they can change the preview's data, spend AI and call outside services. A step that takes the page off the preview's origin ends the steps, and a run is bounded at 46 seconds, its steps at 28: a step the bound reaches reads STOPPED, the steps after it are not run, and the answer reports what ran (steps, steps_stopped). A STOPPED step is not cancelled, so it may still have acted on the page. A run with as or steps lists every request the page made to another origin (other_origin_requests). A desktop screenshot of a visit with neither is kept as the build's latest, a phone one (viewport) or one after steps only under its inspection's id, and one with as nowhere: this answer alone carries it. For a signed-in inspection Exepad's card shows the app's preview, not this report. Where a host drops image blocks, the text is then all that arrives of that inspection. The screenshot is a JPEG, or, on a connection whose host drops image blocks, a PNG in the card's copy of the answer, with the same report as text; a JPEG on a connection with a result budget is attached only while the whole answer stays within the budget, taken at half size, then at a lower quality, when a full one is too large. An answer still past the budget first has its long console messages, exceptions and failed requests cut to 300 characters (truncated counts them), and leaves the screenshot out, as the text then says, only when it still does not fit. Where the conversation shows Exepad's card, the card shows the build's state and a way to open the preview; where the preview cannot be framed in the conversation, it shows the latest screenshot and a link that opens the preview in Exepad. An inspection runs for at most 54 seconds (INSPECTION_TIMED_OUT past it, which says what the browser had seen and what it did not get). A connection may inspect 20 times an hour (INSPECTION_LIMIT past it), and an account's connections together 40 times an hour (RATE_LIMITED past it): Exepad's own limits, enough for an inspection after each build, not one after every change. A run with steps counts as 3 of the connection's inspections, and as 5 units of the account's 120, of which a plain inspection takes 3. A build named by operation_id that is still running is observed first, which can write Exepad's record of it, as get_operation's description states.
inspect_preview
Read a build operation that build_preview started: its state, and once it has ended, whether it built (result.ok), whether its preview can be opened now (result.preview_ready: false once a newer build has replaced it), and for a failed build its diagnostics. Each call waits up to about 45 seconds for the build to end, so a build usually takes one or two calls; while the state is queued, building or deploying, the answer carries retry_after_seconds, after which another call can report new progress. Once it has ended, charge says what the build cost from the owner's wallet. Once a build has deployed, secrets lists, never by value, the secrets exepad.jsonc declares that its preview does not hold (unset) and any the preview holds that are no longer declared (orphaned), each named by the environment key the app's worker reads it under: the declared key, upper-cased. secrets reaches a connection that reads source (source:read); any other gets the rest of the answer. A build's preview reads none of the secrets the owner sets in Exepad, so every declared secret is unset there. Once Exepad has started its check of the app's chat on a succeeded build (an agent with base ai-chat or think in exepad.jsonc, used by two signed-in test users on a private copy of the preview, with scripted model replies and a reload), agent_check reports it: running, then pass, fail or not_measured with its reason. A call on a succeeded build also waits up to about 45 seconds for that check to end; while it may still be on its way (running, or not started yet), the answer carries retry_after_seconds; the check is advisory and never blocks a publish. A succeeded build may also carry warnings: advisory findings no build check refuses, such as a spreadsheet attached to the app in Exepad whose rows have nowhere to live. This call can also write to Exepad's record of a build. While a build runs, calls save its progress. When it is the first to see that a build has ended, it records the outcome; until that is recorded, Exepad counts the build as still running, for this app and for the account's limit on builds at once. A build's deploy records the end of a build that reaches it. One that ends before then waits for a call like this, for the app's page in Exepad while that page follows the build, or for Exepad's scheduled jobs, normally 30 to 45 minutes after the build was requested. In rare cases a call also marks as failed a build that never reached Exepad's builder within two minutes, or one a restart interrupted, and cleans up the machine it left behind. If a success's own record was lost, a call records it, and the preview then shows that build, the one a publish can use. Recording success also saves pending name, derived-address and card work. This call runs none of that work. Exepad's deploy and Studio paths can run it; scheduled jobs try pending work on their next run, normally within 15 minutes, and retry failed attempts. A delayed or failed capture can leave the card waiting longer. Once a build has ended, this call can also decide the build's charge, whether it is charged and how much, if Exepad's scheduled jobs have not, and an amount decided counts at once against what the wallet can spend on the next build. The wallet is debited by a scheduled job, never by this call.
get_operation
Read where a publish of an app stands: one prepare_publish prepared through this connection, by the app's public id and the intent id. It answers the same states as publish_app (pending until the user approves it in Exepad, with approval_url; approved; publishing; published with live_url; failed with reason; expired; cancelled) and never starts or approves a publish: publish_app starts one the approval did not start, and this reports its progress and the live address. A publish under way is read from the deploy as it stands now. This call can also write to Exepad's record of a publish. While a publish is under way, each call saves when it looked and, once named, the release. When it is the first to see that a publish has ended, it records that ended state, published or failed; until that is recorded, Exepad counts the publish as still under way and refuses another publish of the app, and an approval given in that time fails for good. Otherwise publish_app, an Exepad page following the publish (the approval page or the app's publish dialog) or Exepad's scheduled jobs record it, the jobs normally within 15 minutes. A publish that never began within 15 minutes is recorded as failed the same way. What is live changes only by the deploy, never by this call.
get_publish
List the apps connected to this assistant: those the owner selected when connecting, and those created through this connection. Newest first.
list_apps
List an app's releases, newest first (at most 50): each publish to its public address (production) and to its private preview, with its status, the address of a production release, the revision it published when it was a build_preview build, and whether a production release is what the public address serves now. The checks build_preview runs are not releases and are not listed.
list_releases
List an app's source files at its current revision, or at the revision you name: each file's path, size, sha256, class and whether you may write it. The revision it returns is the base_revision_id apply_changes needs. Authored files are yours to change; pinned files (package.json, pnpm-lock.yaml and the other package files) are read-only in this phase. Files the platform supplies or generates at build are not part of the source; get_authoring_guide explains the layout.
list_files
Read an app's workflow run history: metadata about its runs, never what a run was given or returned, or its error text. target preview (the default) reads the runs of the build its private preview shows now, which operation_id names: a preview with no successful build has none, and a newer build's preview starts with none. target production reads the runs at its public address, without each run's id and step names, which the app's code chooses and can build from its users' data. Without ref, the answer is one page of runs, newest first: each run's status, when it started and ended, how many steps it ran and, for a failed run, its cause code and repair, a line on what that code means for the app. Only workflow_replay_diverged names a step (step, step_index); for any other cause Exepad records no failing step, and the step log shows which steps started, not which one failed. status narrows the page to failed or running runs and since to runs created from that instant, and next_cursor, when it is not null, is the cursor of the next page. With ref, the answer is that one run and its step log in order: each step as it started, each wake, sleep and event, and the run's end with its cause code, each with when it happened. truncated says the run has more events than the answer carries. On a connection with a result budget, a page ends early, with its next_cursor, and a step log early, with truncated, where the answer, its text and structuredContent together, would pass that many characters. A connection may read run history 30 times a minute (RATE_LIMITED past it): Exepad's own limit.
list_workflow_runs
Look up the AI operations and other platform capabilities an app may declare in exepad.jsonc for its preview, as Exepad's capability discovery answers them for the app's owner and plan. op search lists the candidates matching an intent (at most 5 unless limit says otherwise), each with a summary, and every profile the app can declare as one row (operation, profileId, profileRevision, retailMode, model, and what a chat or voice profile supports) in enabledOperations, or in declarableOperations when the app's next build grants it; a search with no filter whose intent is absent or matched nothing carries menu instead: every candidate a search shows by default, with its summary. What is left out carries its reason: plan_not_included (the owner's plan does not include it), granted_at_next_build (the app's next build grants it) or not_available_now (Exepad cannot offer it now). op read returns one reference section a search named, with the full native facts of that operation's profiles and each chat profile's owner rate per million tokens (retailInputUsdPerMillion, retailOutputUsdPerMillion); op check answers whether the capabilities demand of an exepad.jsonc text would be granted. An app with data made with create_app through this connection, or converted at this connection's request, has its preview set up when it is created or converted, unless that setup was deferred; any other app's preview is set up by a build of it that reaches its deploy, and until then the lookup is refused GOVERNED_ARTIFACT_ENROLLMENT_PENDING; a one-page site can declare none. A check lists the profiles of the operations its requirements name. On a connection with a result budget, a read or a check that would pass it leaves out profiles, last first, and counts them under truncated, and a search that cannot fit is refused LIMIT_EXCEEDED. It grants nothing: a build's release grants exactly the operation and profileRevision exepad.jsonc declares when the owner's plan includes it, and otherwise fails at release with capability_unavailable on exepad.jsonc. get_authoring_guide's ai topic shows the declaration and a call from the app's worker.
discover_capabilities
For the preview panel: a fresh address that opens a succeeded build's private preview once, for a session of ten minutes. The address is in the result's _meta only. A build the preview no longer shows (a newer build replaced it) is refused PREVIEW_NOT_CURRENT. A build named by operation_id that is still running is observed first, which can write Exepad's record of it, as get_operation's description states.
refresh_preview_session
Prepare publishing an app's latest successful build (the one its private preview shows) at the app's public address. This call publishes nothing: it answers an approval link, approval_url, where the user approves the publish in Exepad within 30 minutes, and the approval normally publishes the app at once, replacing what its public address serves. Once it is approved, publish_app with the intent id starts the publish if the approval did not, and get_publish reports its progress and the live address. Only the latest successful build can be published (BUILD_NOT_LATEST for an older operation_id); an app with none is refused NO_PASSING_BUILD. If the app is built again, published or unpublished before the user approves, the approval is refused, and a new prepare_publish is needed. When the account's plan does not include the publish (an app with data on a plan that publishes only one-page sites, or one of the plan's app limits reached), the answer carries plan: the owner cannot approve it on that plan, and the approval page says what is needed.
prepare_publish
Send one HTTP request to a route of an app's private preview, with no browser, and return its status, its response headers without set-cookie, and at most 16 KiB of its body as text. as is who asks: anonymous has no session; member and second_member each have a session for their own test account Exepad adds to the app's preview, with the role user, and admin for another, with the roles admin and user. App admin lists all three under Users. So it can show that a route refuses a caller who is not signed in, and that one user cannot read another's rows. as admin needs the data:read scope, and any method but GET and HEAD needs preview:act (INSUFFICIENT_SCOPE, or a request to approve them, on a connection without them). The request goes straight to the build's worker, so what answers is the app's own authorisation. It runs the app's real code, whatever the method, which can change the preview's data, spend AI and call outside services. A redirect is returned as it came, never followed. The request has 10 seconds: an app that has not answered by then is refused PROBE_FAILED, as a route that throws is, and a body still arriving then ends there. The session is ended when the call does, and its token is redacted from the answer. A one-page site has no accounts (PREVIEW_UNAVAILABLE). A connection may send 60 probes an hour (PROBE_LIMIT, Exepad's own limit); a probe counts as no inspection. On a connection with a result budget, body ends early, with body_complete false, where the answer, its text and structuredContent together, would pass that budget. A build named by operation_id that is still running is observed first, which can write Exepad's record of it, as get_operation's description states.
probe_route
Read one connected app by its public id: its status, live address, what it is (a one-page site or an app with data), and when it was published. Also what Exepad runs for the app on its preview and at its public address (lanes: workflows, processors, in-app agents and their tools, live voice, and the AI providers the owner's plan includes, each on or why it is off), and what only the owner can do in Exepad, with the Studio page for each (owner_actions: settings and secrets, each secret by name with its state and never its value; the app's administrator; its scheduled jobs and whether each is paused; and connecting a domain, where the owner's plan can). The secrets and the jobs reach a connection that reads source (source:read); any other gets the pages and the administrator's state. Exepad reads these now, within a few seconds (what it reads from the app itself can be up to 30 seconds old), and any it could not read reads unknown. An account's calls read the app itself at most 6 times a minute, across its apps and connections, Exepad's own limit: past it, those facts read unknown. For a connection that runs builds, also its recent builds, from any connection or the Studio, with what each cost, and what all its builds have cost together.
get_app
Read a range of lines of one of an app's source files, at its current revision or the one you name: up to 2000 lines from start_line (1-based). It reads a file of any size, so a file read_files lists in too_large can be read in parts. The answer carries the lines as text, each as the file has it and joined with line feeds; the range returned (start_line to end_line); the file's total_lines; and the whole file's sha256, which apply_changes accepts as expected_sha256. On a connection with a result budget, the answer, its text and structuredContent together, stays within that many characters: when the lines asked for would pass it, the answer carries as many whole lines as fit, with truncated true and next_start_line, the first line not returned. A path the revision does not have is refused FILE_NOT_FOUND, a start_line past the last line INVALID_ARGUMENTS, and a line whose answer alone, counted that way, would pass the budget LIMIT_EXCEEDED (at 80,000 characters, a line of about 39,000). A binary path answers path, decoded byte size and sha256 with binary true, without text or line numbers.
read_file_range
Read the text of up to 20 of an app's source files, at its current revision or the one you name. A file over 256 KiB, or one that would take the answer past 512 KiB, is listed in too_large with its size instead; on a connection with a result budget, so is a file that would take the answer, its text and structuredContent together, past that many characters. read_file_range reads a file listed in too_large in parts, a range of its lines at a time. A path the revision does not have is listed in missing. Each file carries its sha256, which apply_changes accepts as expected_sha256. Binary paths appear in binary with path, decoded byte size and sha256, without content; they are not text files.
read_files
Read the Exepad account this connection belongs to: its email; its plan, with whether the plan can publish an app with data (fullstack_publish) and connect a domain; how many apps it has against the plan's limits; what this connection may do; and, for a connection that runs builds, what the account's wallet can spend on builds now, its monthly build credit included. Plan changes, payments and purchases are outside this connection; no tool here performs them or provides purchase instructions.
get_account
Read Exepad's reference for writing an app through these tools, one topic at a time. overview: the file layout, which files apply_changes may write, how a revision is built and previewed, and what each refusal code means. manifest: exepad.jsonc (bindings, settings, accounts, schedules). data: models, SQL routes, migrations and files. api: the worker entry, sign-in, settings and secrets. ai: how an app with data declares and calls AI models, and what discover_capabilities lists. ui: routing, theme, components and fonts. design: the look, decided as three concepts in DESIGN.md from 13 direction presets. types: every generated type and SDK export. An Exepad app follows platform rules that a generic React or Workers app does not, and the topics state them.
get_authoring_guide
For Exepad's card: a screenshot of a build's private preview, in the result's _meta (exepad.screenshot, a JPEG or PNG in base64), or why there is none (exepad.screenshot_omitted: none, too_large, not_built or not_kept). With inspection_id and its operation_id it is exactly that inspection's screenshot, or not_kept when Exepad no longer keeps it; nothing is captured then. Otherwise it is the build's latest screenshot, of the page last inspected on a desktop screen as a visitor with no steps: the build named, else the app's latest successful build. A successful build with no screenshot yet, or only one another connection took that is too large for this answer, is captured once, at /, which counts as one of the connection's 20 inspections an hour. A build named by operation_id that is still running is observed first, which can write Exepad's record of it, as get_operation's description states.
get_preview_screenshot
Read Exepad's reference edition: the written recipes and references for what an Exepad app can do, such as AI calls, voice, agents, workflows, files, email and realtime. With no id and no file, the answer lists every item with its title, its size, the AI operations it names and its headings. id answers that item's main text and file one file by the path an item's answer lists, such as recipes/voice-agent/README.md; either lists the item's files. A long text comes in pages, and next_cursor, when it is not null, is the cursor of the next page. The edition stays in step with the knowledge Exepad runs on: while a release moves the two, a call is refused REFERENCE_UNAVAILABLE, which is retryable. On a connection with a result budget, a page ends early where the answer, its text and structuredContent together, would pass that budget, and a budget too small for the answer is refused LIMIT_EXCEEDED.
read_reference
Rename an app connected here: the name the user sees in Exepad (1 to 80 characters, one line). While the app has never been published, its address is still the one Exepad derived from a name, and no publish of it is waiting for approval, its public address follows the new name; otherwise the address does not change. The app's description is what the user first asked for and is never changed.
update_app
Request turning a one-page site into an app with data, for the user to confirm in Exepad by typing the app's address. This call only records the request and answers a link, which works for 15 minutes: nothing changes until the user confirms there, and every call is a new request. Once it is confirmed, get_app reports capability_profile fullstack, and the app's source has one new revision holding the full-stack worker entry (src/worker/index.ts) and, when the source had no migrations, migrations/README.md; exepad.jsonc and the app's other files are as they were, so what the app needs is declared and written in later revisions. A conversion cannot be undone, and the app keeps its address and its history. A live site keeps serving what it serves until a later publish, except where the page says it goes offline, and the page states what changes for publishing and hosting. An app with data is refused ALREADY_FULLSTACK, and one built in the Studio's own workspace APP_NOT_MANAGED.
prepare_profile_change
This tool requests one file for the user to choose and upload in Exepad. This call records a destination and returns a link; it takes no file bytes or local filename. The link lasts 30 minutes and is single use. Nothing changes until the user chooses a file and presses Upload there. The destination is under public/ and ends in .png, .jpg, .webp, .avif, .gif, .ico, .woff2, .mp3 or .ogg. The file must match that type and be at most 1 MiB. The upload adds or replaces that file on the app's source at upload time, preserving other changes made since this request. It appears in list_files once complete; the user returns to the chat to say it is ready. It becomes publicly readable after a separately approved publish, even when the app requires sign-in. Every call creates a new request.
prepare_asset_upload
Request a value for a setting or a secret an app declares in exepad.jsonc's params, for the user to enter in Exepad. This call only records the request and answers a link, which works for 30 minutes: nothing changes until the user enters the value there, and every call is a new request. No value or default is sent or shown, and no tool returns a secret's value. key must be declared by the target's latest release: on preview the latest passing build, on production the latest publish, so a key not declared there is refused SETTING_NOT_DECLARED. A secret is requested for production only, because the preview a build serves holds none of the user's secrets (SECRET_PRODUCTION_ONLY); any other setting works on both targets and is stored in that target's database. A model provider key and Exepad's own names are refused SETTING_RESERVED, whatever the app declares. The page names this connection and states that the app's code can read the value and send it elsewhere. The value replaces any value the setting held, and on production it changes what the live app does for everyone who uses it. Once a secret is set, get_app's owner_actions reports it as set to a connection holding source:read.
prepare_setting
Search an app's source for literal text (not a pattern), at its current revision or the one you name, optionally under one path prefix. Returns up to 200 matching lines with their path and line number, the app's own files before its package files, each line cut at 400 characters; on a connection with a result budget, the lines stop where the answer, its text and structuredContent together, would pass that many characters. truncated says more lines matched. Binary paths are skipped.
search_files
Start a publish that prepare_publish prepared, once the user has approved it in Exepad: it starts the publish if the approval did not, and answers where it stands (publishing, published with live_url, or failed with reason). Before the approval it is refused APPROVAL_REQUIRED with the approval link; only the user approves a publish, in Exepad. get_publish reports a publish's progress and the live address without starting anything, so one publish_app call per publish is enough. A publish under way is observed first, which can write Exepad's record of it, as get_publish's description states.
publish_app
Exepad ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Exepad's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Exepad alternatives on ChatGPT?
As of 2026-11-20, Exepad competes with Adalo, Akwadra, Alpy, Apiway — AI Workspace, App Builder, AppCreator24 – APK Builder, AppDeploy, appdesigns and 54 more in ChatGPT AI App & Website Builders, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.