> ## Documentation Index
> Fetch the complete documentation index at: https://help.teable.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# App Builder: create and publish AI-built apps

> Turn project tables into a web app with prompts. Edit and preview the app, configure login and a custom domain, then publish or roll back a version.

> [!NOTE]
>
> Available on all Cloud plans; Self-Hosted requires Business or higher.

Teable App Builder allows you to turn your projects into fully functional, customized web applications without writing code. By combining the power of your data structure with AI-driven design, you can launch internal tools, customer portals, and data dashboards in minutes.

## Overview

The App Builder follows a "Prompt to App" workflow. You describe what you want, and AI builds the application structure, pages, and logic for you. You can then fine-tune every detail using the visual editor or code.

> [!NOTE]
>
> Use App Builder to create custom interfaces and standalone apps. For interactive data analysis and ad-hoc questions inside the project, use [AI Chat](https://help.teable.ai/en/basic/ai/ai-chat.md).

For practical use cases, see [AI app builder examples](https://teable.ai/ai-app-builder).

## Creating an App

There are two main ways to create an app:

1. **From Project**: In any Project, click "Create app" to generate an application linked to your current data.
2. **From Chat**: Open AI Chat and say "Create a CRM app for this customer table".

For an education example, see how [Zakrly organizes teaching data and designs student portal interfaces](https://teable.ai/customers/zakrly).

## The App Editor Interface

The App Builder provides a dual-interface for both non-technical users and developers.

![App Builder editor interface](https://mintcdn.com/teablecn/enxjqLV-OFVGkYUK/images/docs/ai/2026-11-11-app-builder-editor-interface.png?fit=max\&auto=format\&n=enxjqLV-OFVGkYUK\&q=85\&s=e01cb39780acff81a335d69d407d85fb)

### 1. Chat Interface (AI-Driven)

The command center for your app.

* **Natural Language Editing**: Describe changes like *"Make the header blue"* or *"Add a submission form for new records"*.
* **Auto-Routing**: The AI understands which component or page you are referring to and modifies it directly.
* **Credential requests**: When the app needs access to a third-party account or a secret at run time, App Builder pins a card to the chat panel, such as **This app needs your Slack connection**. Click **Connect my account** to run an OAuth flow; the new connection is granted to this app right away. If you already have a usable connection or secret, just grant it; there is no need to connect again. Click **Skip** to withhold the credential; AI continues with the parts it can complete without it.
* **Skills**: Open the **+** menu and choose **Skills** to manage skills for this app conversation. A skill added here is only available to the current app, and the skills shared with the app's project and space can be used here as well. Type `/` in the input box to choose an enabled skill.
* **Manage files**: Open **+** → **More** → **Manage files** to view files in the app sandbox. Use it to preview supported files, download generated files, or delete files and folders you no longer need.
* **Clear Conversation**: If the current conversation has drifted, click the **`...`** button at the top of the chat panel and choose **Clear chat** to start a new session. This clears the chat history for the current conversation but does not delete the app itself. The first use shows a confirmation, and you can choose not to show it again next time.

### 2. Preview Panel

* **Preview and Live**: The panel has two tabs. **Preview** runs the version you are building, including changes that are not published yet. **Live** loads the published app from its public address, so you can compare what your users see with what you are working on. Until the app is published, **Live** shows a publish prompt instead. App Builder opens a published app on **Live** and an unpublished one on **Preview**, and afterwards remembers the tab you last used for that app.
* **Multi-Device Simulation**: Use the switcher at the top to toggle **Desktop**, **Tablet**, and **Mobile** views.
* **Live Generation**: The preview panel can show the app taking shape while App Builder is generating.
* **Instant Feedback**: After App Builder finishes a change, the preview refreshes with the latest saved version.

On the **Preview** tab, use the floating toolbar at the bottom to make targeted changes:

* Choose **Select an element to edit**, then click an element in the preview. App Builder adds the element to the chat input. Add your instruction and send the message so AI can update that specific part of the app.
* Choose **Edit text directly**, then click static text in the preview and type your replacement. You can edit more than one text element before clicking **Save**. Click **Discard edits** to undo the pending text changes.

Dynamic text, such as content loaded from data or calculated by the app, cannot be edited directly. Select the element and describe the change in chat instead. Element selection and direct text editing pause while AI is generating. Press `Esc` to exit either mode.

### 3. Developer Mode (Code Editor)

For infinite customization, you have direct access to the code.

* **Monaco Editor**: A VS Code-like experience right in the browser.
* **React Components**: Edit the underlying React code, Tailwind CSS classes, and logic.
* **File Tree**: Navigate through the project structure.

![App Builder code editor](https://mintcdn.com/teablecn/enxjqLV-OFVGkYUK/images/docs/ai/2026-11-11-app-builder-code-editor.png?fit=max\&auto=format\&n=enxjqLV-OFVGkYUK\&q=85\&s=c3d85135f02944de88bff72e6993396f)

#### Download Code

You can download the entire app as a ZIP archive at any time:

1. Click the **Settings** button (slider icon) at the top of the app and choose **Code**.
2. Click the **`...`** menu at the top of the code view.
3. Select **Download code**, then click **Download code** again in the dialog to save a ZIP archive that includes all source files.

![The Settings menu at the top of the app, with Sign-in settings, GitHub sync, Code, and Version history](https://mintcdn.com/teablecn/enxjqLV-OFVGkYUK/images/docs/ai/2026-11-11-app-builder-settings-menu.png?fit=max\&auto=format\&n=enxjqLV-OFVGkYUK\&q=85\&s=e117006aeb32e3ba1865c2b3a4556635)

By default the ZIP leaves out the app's live credentials. Its root holds a `.env.example` that lists the [platform-injected runtime variables](#teable-access-token) (the ones Teable adds to every app automatically) with the Teable access token and the AI access key left blank, and a `.gitignore` that keeps `.env` files out of Git.

To run the code locally right away, select **Include .env with live credentials** in the dialog. The ZIP then holds the real `.env` instead: the platform-injected runtime variables, including the Teable access token and, when AI access is on, the AI access key. Credentials granted to the app are not part of it.

> [!WARNING]
>
> Anyone who has this `.env` can read and change all data in the project the app belongs to. Don't commit it to a repository or share it; if it may have leaked, [rotate the Teable access token](#teable-access-token).

#### Import Code

You can update the app's code by importing a ZIP:

1. Click the **Settings** button at the top of the app and choose **Code**.
2. Click the **`...`** menu at the top of the code view.
3. Select **Import code** and choose a ZIP file up to 20 MB.

> [!NOTE]
>
> * Include source files only. `node_modules`, `.next`, and other build artifacts are ignored automatically.
> * The ZIP replaces the existing project. Files you leave out are removed from the new version.
> * If the ZIP contains one wrapper folder, Teable strips that folder. You can compress the outermost project folder directly.
> * The imported project must include `package.json` at the project root.
> * Custom variables in a root `.env` file are stored as your secrets and granted to the app under the same names. Other `.env*` variants, such as `.env.local`, are ignored.

#### Credentials and Config

Keep API keys, credentials, and configuration out of your source. An app uses **your credentials**: an OAuth connection or a secret you store. In the App Builder chat panel, open **+** → **More** → **Credentials & config** and grant a credential to the app.

| Detail | Behavior |
| - | - |
| Availability | Credentials granted to the app are available in the app preview environment and the published app |
| Variable name | The alias you enter when granting; it must start with an uppercase letter and can contain uppercase letters, digits, and underscores |
| Reading a secret | Server-side app code reads environment variables such as `process.env.MY_API_KEY` |
| Reading a connection | Server-side app code calls `getConnectionToken('ALIAS')` for an access token |
| Saved values | Values are write-only after saving; enter a new value to replace one |

After you add a grant, remove one, or replace a credential value, the app preview environment uses the new value. The published app uses it only after you republish.

Copying an app does not copy its credentials: the panel keeps **Not bound yet** placeholders, and **Bind mine** supplies your own. Copying or exporting a project, or using a template, doesn't carry the `.env` in the app's code either, and each copied app gets its own Teable access token. See [Credentials and Integrations](https://help.teable.ai/en/basic/credential.md) for managing credentials and checking where they are used, and [Duplicate a Project to Another Space](https://help.teable.ai/en/basic/base.md#duplicate-a-base-to-another-space) for how tables, records and the rest of a project are copied.

#### Teable Access Token

An app's environment variables come from two sources:

* **Platform-injected variables**: Teable provides them to every app, including the Teable access token (`TEABLE_APP_TOKEN`), the API endpoint, and the app and project IDs. With **AI access** on, the AI access endpoint and key are added.
* **Credentials granted to the app**: the secrets and connections you grant in **Credentials & config**, described above.

Personal access tokens (**Settings** → **Developer tools** → **Personal access tokens**) are never injected into an app, and app code doesn't need one; they are for calling Teable from outside the app. See [Credentials for External Services and MCP](#credentials-for-external-services-and-mcp).

The Teable access token is the credential the app uses to read and write data. It can access the whole project the app belongs to; it can't be limited to some tables or fields, and it can't reach other projects. It is used in the app preview environment and the published app. Teable never commits it to the app's repository, and downloaded code leaves it out by default. Normally each app has its own token; see [When the Token Changes or Stops Working](#when-the-token-changes-or-stops-working).

Rotate the token when:

* It may have leaked, for example a `.env` was committed to a repository, or pasted into a GitHub issue, a forum post or a chat.
* A member who copied the env variables or downloaded code with a `.env` no longer works on the project.
* The app's code was handed to someone together with its `.env`.

In the chat panel, open **+** → **More** → **Credentials & config**, and click **Rotate** at the top right of the **Platform credentials** card. The Teable access token and the AI access key are both rotated here, which requires edit access to the app.

When the app has AI access on, the confirmation lets you choose what to rotate: **Teable access token**, **AI access key**, or both, which is the default. A `.env` holds both values, so if you suspect it leaked, rotate both. Whether you rotate one or both, the preview and the published app update only once. The confirmation lists the effects of what you selected.

| Item | After rotation |
| - | - |
| Old token | Stops working at once |
| Running preview | Switches to the new token without a restart |
| Published app | Teable redeploys it in the background with the new token; nothing new appears in Version History. Until the redeploy finishes, usually within a few minutes, the app can't read or write project data. If the app has unpublished changes, Teable redeploys the version that is already published, and your unpublished changes stay unpublished |
| Signed-in app users | If the app uses [App Login](#app-login), visitors must sign in again |
| Local `.env` and downloaded code | The old token in them no longer works; copy the env variables again, or download the code with **Include .env with live credentials** selected |

Some apps from older project copies share one token. Rotating one of them also rotates every other app in the project that still shares it, each to its own new token, and a notice tells you how many were rotated.

Teable's automatic redeploy only switches the token: it rebuilds the version that is already published and never publishes changes you haven't published. Republishing is you publishing the current version from the publish panel, unpublished changes included. If you see **Credentials rotated, but the published app couldn't be updated automatically. Republish it.**, or this app (or an app rotated with it) still can't read data after a few minutes, republish that app so it picks up the new token. If the preview can't read data, reload the preview.

#### When the Token Changes or Stops Working

| Action | Teable access token |
| - | - |
| Create an app | A new token is issued |
| Copy an app, copy or import a project, use a template | Each copy gets its own new token; the original app's token is unchanged |
| [Move the app to another project](https://help.teable.ai/en/basic/base.md#move-resources-to-another-project) | Replaced with a new token, and the old one stops working at once. The preview switches to the new token and the published app is redeployed in the background, as after a rotation |
| Publish, republish, roll back a version | Unchanged |
| Unpublish | Unchanged; the token keeps working and the preview keeps using it |
| Download code, copy the env variables | Unchanged; you get the same token every time until it is rotated |
| Rotate | Replaced with a new token, and the old one stops working at once (see above) |
| Delete the app | Stops working at once. If the app is restored from the trash, the same token works again |

A token is issued with a 10-year lifetime and works until it is rotated or the app is deleted; it doesn't expire on its own. If you suspect a leak, rotate it. If you restore an app from the trash and its token may have leaked, rotate it after restoring.

#### Audit Records

These actions are recorded in the audit log:

* **Rotate app access token** and **Rotate app AI key**: a rotation from the **Platform credentials** card records one entry for each credential rotated.
* **Copy app env variables**: copying the env variables, which include the access token.
* **Export app code**: downloading the code; the record shows whether the `.env` was included.

When an app writes project data with its access token, the audit log shows **App Robot** as the operator. Per-token usage history and alerts aren't available, and reads aren't recorded.

On self-hosted instances (Business plan and above), instance administrators view the log under **System Admin** → **Audit log**. Logs are kept for one month and can be filtered by user, space, project and operation type; the entries above are under **Apps**. See [Audit log](https://help.teable.ai/en/basic/admin-panel/audit-log.md).

#### Credentials for External Services and MCP

The Teable access token is only for the app itself. Don't use it in services outside the app; it can't be used to connect MCP either.

* **External services calling the Teable API** (for example serverless functions, scripts or CI): use a [personal access token](https://help.teable.ai/en/api-doc/token.md). Add only the projects or spaces and the scopes it needs, and set an expiry date. A personal access token acts as the user who created it.
* **MCP clients**: connect with OAuth (recommended). The client acts as you, and you can remove it at any time under **Settings** → **Developer tools** → **MCP**. Where there's no browser, use a personal access token instead, again with only the projects and scopes it needs. See [Connect Through MCP](https://help.teable.ai/en/basic/ai/teable-skill.md#connect-through-mcp).

#### Manage App Files

App Builder stores uploaded files, generated outputs, and runtime files in the app sandbox. In the chat panel, open **+** → **More** → **Manage files** to inspect them. Supported file types open in preview. You can also download files or delete files and folders you no longer need.

#### Add AI Features to an App

Add AI when your app needs to summarize records, classify requests, draft replies, or answer questions for app users.

You can tell App Builder what you want, such as: "Add an AI reply assistant for support tickets" or "Summarize each form submission." App Builder can turn on **AI access** and add the code for the feature.

> [!NOTE]
>
> After App Builder adds the AI feature, the app preview uses the new version. The published app uses it only after you republish.

Teable injects the AI access key too, and the **Platform credentials** card shows it next to the access token. To replace it, click **Rotate** on the card and select only **AI access key**: the old key stops working at once, the running preview switches to the new key, and the published app redeploys in the background; its AI calls fail until that finishes. Rotating only the AI access key doesn't sign visitors out. If the app has unpublished changes, the version that is already published is redeployed and your changes stay unpublished. If AI calls still fail after a few minutes, republish the app.

## Sync Code with GitHub

> [!NOTE]
>
> Available on Cloud Business plans and above.

Link an app to a private GitHub repository when you want to review code in pull requests, keep a copy outside Teable, or work on the app in your local editor. Once linked, the app and the repository sync in both directions: every new app version is pushed to GitHub, and commits you push to GitHub become new app versions.

### Connect an Account and Create the Repository

Generate the app at least once first. Until the app has code, **GitHub sync** in the **Settings** menu is grayed out and can't be selected.

**1. Open the GitHub panel**

Click the **Settings** button at the top of the app and choose **GitHub sync**. You need edit access to the app.

**2. Connect an account**

Click **Connect GitHub** and complete the installation in the popup window. Choose your personal account or an organization you administer. Allow popups if your browser blocks the window.

**3. Pick the account**

Select the connected account under **GitHub account**. Click **+** to connect another one.

**4. Name the repository**

**Repository name** is prefilled from the app name. Names may contain letters, digits, `.`, `-`, and `_`, up to 100 characters.

**5. Create and link**

Click **Create repository & link**. For a personal account, GitHub asks you to authorize the creation in one more popup.

Teable creates a new private repository and commits the current app code to the `main` branch, along with a README that points back to the app and explains how the two stay in sync. You cannot link an app to a repository that already exists.

By default a connection belongs to whoever created it. To let collaborators build on the same organization account, select the connection and turn on **Allow other members to use this connection**. Other members with app editing access can then create repositories for their own apps under that organization. Personal connections cannot be shared, because GitHub requires the account owner's own authorization to create a repository.

### How Syncing Works

| Direction | What happens |
| - | - |
| App → GitHub | Each new app version is pushed to the `main` branch of the repository. |
| GitHub → app | Commits pushed to `main` become a new app version. A message in the chat panel reports what was synced, and an open preview reloads on the new code. |

Environment files are never pushed. See **Environment Variables and Local Development** below.

The panel shows the current state next to the repository name:

| Status | Meaning | What to do |
| - | - | - |
| **Synced** | The repository matches the latest app version. | No action needed. |
| **Syncing** | A push is in flight. | Wait; the panel updates on its own. |
| **Conflict** | The `main` branch has commits Teable did not produce, and they cannot be combined automatically. | Merge the `teable-sync` branch on GitHub. See below. |
| **Paused** | Teable stopped syncing because the GitHub App was uninstalled or suspended. | The panel says which. Lifting a suspension resumes syncing on its own. |
| **Error** | The last sync attempt failed. | Read the reason in the panel and click **Retry**. |

### Resolve a Conflict

Teable never force-pushes your branch. When the histories diverge, it parks the latest app version on a branch named `teable-sync` and marks the link **Conflict**. Merge `teable-sync` into `main` on GitHub; the merge comes back as a new app version and the link returns to **Synced**. While the conflict lasts, later app versions keep moving the `teable-sync` branch forward, so merging it always brings in the newest work.

### Environment Variables and Local Development

The repository holds source only. Teable never pushes a file whose name starts with `.env`: not at the project root, not in a subfolder, and not in the commit history. Environment values come from the platform-injected variables and the credentials granted to the app (see [Teable Access Token](#teable-access-token)); Teable manages them, and they never enter Git. The repository's `.gitignore` already lists `.env*`, so a local clone will not commit one by accident.

To run the app on your own machine:

**1. Clone and install**

Clone the repository and run `pnpm install`.

**2. Copy the variables**

In the GitHub panel or in **Credentials & config**, click **Copy env variables to clipboard**, then paste the clipboard into a `.env` file at the project root.

**3. Start the app**

Run `pnpm dev`.

The copied content holds only the variables the platform injects: the API endpoint, the access token, and the AI access variables. In **Credentials & config**, the button also notes **Only platform-injected runtime variables — granted credentials are not included**. Neither the copied variables nor downloaded code include credentials granted to the app; add any you need for local debugging to the `.env` yourself.

> [!WARNING]
>
> The `TEABLE_APP_TOKEN` line in that file grants access to the app's data, which is why only members with edit access to the app can copy it. Never commit the file, and never paste it into an issue or a pull request. If it may have leaked, [rotate the Teable access token](#teable-access-token).

To add or replace a credential the app uses in production, use **Credentials & config** in Teable; editing the local file or committing a `.env` to GitHub has no effect. After a platform variable changes, such as a rotated Teable access token or AI access key, copy the variables again to refresh your local `.env`.

### Unlink the Repository

Click the delete icon next to the repository name and confirm. Syncing stops, and the repository and its code stay on GitHub. Linking the same app again later creates a new repository rather than reconnecting to the old one.

## Publishing & Management

### Publishing Your App

When your app is ready, click the **Publish** button (arrow icon) in the top right corner.

* **Public URL**: Teable generates a secure, publicly accessible URL for your app.
* **Custom domain**: Map your own domain to the app.
* **Show branding**: Use **Show branding** in the **Publish** menu to control whether the published app shows the **Build with Teable** badge. If you change this setting after publishing, click **Redeploy** to apply it.
* **Unpublish**: For a published app, use **Unpublish** in the publish menu to take the public link offline.
* **App configuration changes**: When the publish menu shows **Runtime configuration changed. Redeploy to apply it to the live app** or **Branding setting changed. Redeploy to apply it to the live app**, click **Redeploy**.
* **Open published app**: Once an app is published, the icon next to **Publish** opens the live app in a new tab.

> [!NOTE]
>
> Hiding the **Build with Teable** badge requires the Business plan or above.

![Publish app menu](https://mintcdn.com/teablecn/enxjqLV-OFVGkYUK/images/docs/ai/2026-11-11-app-builder-publish-app.png?fit=max\&auto=format\&n=enxjqLV-OFVGkYUK\&q=85\&s=b086b4c508d3af567e366907e7c656a6)

For a public website example, see how [Waconzy brings music, tools, and digital services together with App Builder](https://teable.ai/customers/waconzy).

### Unpublish an App

To take a published app offline, open the **Publish** menu and click **Unpublish**. After you confirm, the public app URL can no longer be accessed.

![Unpublish app button in the publish menu](https://mintcdn.com/teablecn/enxjqLV-OFVGkYUK/images/docs/ai/2026-11-11-app-builder-unpublish.png?fit=max\&auto=format\&n=enxjqLV-OFVGkYUK\&q=85\&s=2cf4c8783802a9e406512626c00127f1)

Unpublishing does not delete the app or its edit history. You can keep editing the app and publish it again later.

### Custom Domains

> [!NOTE]
>
> Custom domains require the Business plan or above.

On a self-hosted deployment that does not run apps on Vercel, clicking **Custom domain** opens the [App domains](https://help.teable.ai/en/deploy/app-domains.md) setup guide, and a server administrator maps the domain. The steps below apply to Teable Cloud.

Use **Custom domain** to bind a domain to the published app. A subdomain is recommended, such as `app.yourdomain.com`. After you enter the domain, Teable shows the DNS records to add. Add the records with your DNS provider, wait for propagation, then verify the domain in Teable.

You can also use an available subdomain under `teable.app` and edit the `teable.app` prefix, such as `your-name.teable.app`.

When the space's Business plan expires, Teable notifies the space owners that the custom domain will stop resolving. Renew before then to keep the domain. If the plan isn't renewed, the custom domain stops resolving and the app's public link reverts to the default Teable address. If you upgrade to Business again later, you need to bind the custom domain again manually.

![Custom domain settings](https://mintcdn.com/teablecn/enxjqLV-OFVGkYUK/images/docs/ai/2026-11-11-app-builder-custom-domain.png?fit=max\&auto=format\&n=enxjqLV-OFVGkYUK\&q=85\&s=6672ada86ea0e359736f0d7b7c42ff2f)

### Custom Site Info

Use **Custom site info** in the **Publish** menu to set the browser tab icon, page title, and description of the published app. The dialog previews how they look together as you edit.

| Setting | What it controls |
| - | - |
| **Favicon** | The icon shown in the browser tab. Upload a PNG, JPEG, WebP, SVG, or ICO file up to 5 MB; 32×32 is the recommended size. Remove the uploaded file to return to the default Teable icon. |
| **Title** | The page title, up to 120 characters. |
| **Description** | The site description in the page metadata, up to 500 characters. |

Leave a field empty to keep the value App Builder wrote for you. Saving applies the change to the app preview environment; the published app uses it only after you republish.

### App Login

Click the **Settings** button at the top of the app and choose **Add sign-in** to require visitors to sign in before they can use the app. Once sign-in is configured, the menu item changes to **Sign-in settings**; after you turn sign-in off, it shows **Sign-in disabled**.

![App login settings](https://mintcdn.com/teablecn/enxjqLV-OFVGkYUK/images/docs/ai/2026-11-11-app-builder-login-settings.png?fit=max\&auto=format\&n=enxjqLV-OFVGkYUK\&q=85\&s=b9c30ff5d40472da57e1b779b5366c82)

When you enable login:

1. Choose where to store app users. You can create a **Users** table or reuse a table that another app already uses as its user table. Each signed-in user is stored as one record, and the same user table can be reused by multiple apps.
2. Choose at least one sign-in method, such as **Email OTP**, **Google**, **SSO (OIDC)**, or **Sign in with Teable**. Available methods depend on your instance's authentication settings. When you turn on **SSO (OIDC)** for an app created earlier, the AI adds the SSO button to its sign-in page automatically.
3. Choose an access policy: **Anyone can sign up**, **Allowed email domains**, or **Invite only**.

After sign-in is configured, open **Sign-in settings** and use **Preview as** to pick someone from the user table, then click **Preview** and confirm; the preview signs in as that user without a code. If the user table is empty you can add a user right there, and users the allowed email domains turn away are greyed out. Click **Sign out** to end it. This sign-in works only in the preview and expires after one hour.

Login changes appear in the app preview environment after it reloads. Publish the app again to apply those changes to the published app.

If you need your own Google OAuth client, login codes sent from your own email address, or password login, explicitly request it in the chat. App Builder will turn off the built-in platform login and implement custom login in the app. Check login and page access controls in the preview before publishing the updated app.

For examples of this feature in use, read [app login examples](https://teable.ai/blog/built-in-login-for-app-builder).

### Version History & Rollback

Teable automatically tracks every deployment.

* Click the **Settings** button at the top of the app and choose **Version history** to view a list of all deployed versions.
* **One-Click Rollback**: If a new update causes issues, you can instantly revert the live app to any previous stable version.

![App version history](https://mintcdn.com/teablecn/enxjqLV-OFVGkYUK/images/docs/ai/2026-11-11-app-builder-version-history.png?fit=max\&auto=format\&n=enxjqLV-OFVGkYUK\&q=85\&s=f49c0d46da6d82309f7f43974c1cab38)

App Builder saves the changes of each round as a new version. When saving fails, a card appears in the chat.

> [!WARNING]
>
> The changes from the failed round stay in the sandbox only; they are lost when the sandbox is reclaimed, and regenerating the reply does not save them again. Act on the card promptly.

* **Version save failed**: this version was not saved. Let App Builder keep working, and the next successful save carries these changes along.
* **Changes too large to save**: this round exceeds the save size limit. Click **Send to AI** on the card and App Builder looks for oversized test artifacts, debug files, or attachments, cleans them up, and saves again. Such files may already be in the unsaved commit history, so deleting them may not be enough; let App Builder tidy that up as well.

### Auto-fix

If your custom code changes cause a build error, the deployment will fail.

* Teable provides an **Auto fix** button alongside the error log.
* Clicking this lets AI analyze the compilation error and automatically patch the code to resolve the issue.

### Deleting an App

To delete an app, click the **`...`** button at the top of the app and select **Delete**.

## Best Practices

For prompt patterns, build tips, rollback advice, and common troubleshooting, see [App Builder Practical Guide](https://help.teable.ai/en/basic/ai/app-builder-practical-guide.md).

## FAQ

> [accordion] Does clearing the conversation delete the app?
>
> No. Clearing the conversation only removes the chat history for the current app conversation. It does not delete the app itself. Use it when the conversation has drifted and you want to start again.

> [accordion] How do I download or import app code?
>
> Click the **Settings** button at the top of the app and choose **Code**, click the **`...`** menu at the top of the code view, then choose **Download code** or **Import code**. Imported ZIP files can be up to 20 MB and replace the existing project, so include every source file you want to keep. The imported project must include a root `package.json`. Custom variables in a root `.env` file are stored as your secrets and granted to the app under the same names.

> [accordion] What should I do if an app's access token leaks?
>
> In the chat panel, open **+** → **More** → **Credentials & config** and click **Rotate** on the **Platform credentials** card; if the app has AI access, keep both credentials selected. The old token stops working at once, and the preview and the published app switch to the new one automatically. While the published app redeploys, usually for a few minutes, it can't read or write data, and if the app has login turned on, visitors must sign in again. See [Teable Access Token](#teable-access-token).

> [accordion] When do sign-in settings apply to the live app?
>
> Changes to **Sign-in settings** appear in the app preview environment after it reloads. Publish the app again to apply those changes to the published app.

> [accordion] How can an app call AI models at runtime?
>
> Tell App Builder what AI feature you want, such as a reply assistant, submission summary, or request classifier. App Builder can enable **AI access** and add the code for the feature. The app preview uses the new version after App Builder finishes the change. The published app uses it only after you republish. AI calls made through this app appear as **App AI** in the credit usage details.

> [accordion] How are Built-in AI and In-app AI charged?
>
> **Built-in AI** includes AI features available directly in Teable, such as AI field generation, AI Chat, IM bots, and App Builder. These features currently use credits at a significantly discounted rate.
>
> **In-app AI** refers to AI features used inside apps created with App Builder. Usage is charged at the selected model provider's [official API price](https://vercel.com/ai-gateway/models), with no markup or discount. US\$1 of API usage equals 100 credits.

> [accordion] How do I roll back to a previous version?
>
> Click the **Settings** button at the top of the app and choose **Version history** to view deployed versions, then restore the live app to a previous stable version.

> [accordion] Why does App Builder say the concurrent conversation limit is reached?
>
> Each user can run up to 3 agents at the same time, including AI Chat and App Builder. If App Builder shows `Concurrent conversation limit (3) reached. Please wait for one to finish.`, another task is still running. Wait for the previous task to finish before continuing.

> [accordion] How are credits refunded when an App Builder run fails?
>
> One App Builder run can include multiple processing steps. The conversation and billing page both show the total credits for that run. Work that Cuppy already completed and saved can still be used. If the final step is interrupted by an unexpected error, credits for that interrupted step are refunded automatically. You can continue working in the same app conversation.

> [accordion] Where do I configure App Builder for Self-Hosted?
>
> If you are running Teable self-hosted, follow the setup on the [AI Settings](https://help.teable.ai/en/basic/admin-panel/ai-setting.md) page. If App Builder uses your own key (BYOK), the chat model must come from an **OpenAI Compatible** or **Anthropic** provider. For deployment support, contact Teable at **[support@teable.ai](mailto:support@teable.ai)**.
>
> > [!NOTE]
> >
> > If you select **Vercel** under **Deployment engine**, make sure both your Teable instance and object storage (MinIO / S3) are publicly accessible, then use **Test public access** on the [AI Settings](https://help.teable.ai/en/basic/admin-panel/ai-setting.md) page. This check is not required when you select **Teable Infra**.

If you are comparing platforms, read [Teable vs Lovable](https://teable.ai/compare/lovable-alternative) or [Teable vs Softr](https://teable.ai/compare/softr-alternative).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.