> For the complete documentation index, see [llms.txt](https://manual.bubble.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://manual.bubble.io/help-guides/ai/bubble-mcp.md).

# Bubble MCP

Bubble's MCP server lets you connect an AI tool like Claude, Claude Code, or Codex to your Bubble account. Once it's connected, you can ask the AI tool to create a new app or make changes to an existing one, and it builds directly in Bubble. The result is a regular Bubble app that you can open, review, and edit in the visual editor like any other. The Bubble MCP supports building both web apps and native mobile apps.

This article explains what MCP is, why you might use it, how it differs from Bubble AI, and how to connect your AI tool.

## What is MCP?

MCP stands for [Model Context Protocol](https://en.wikipedia.org/wiki/Model_Context_Protocol). It's an open standard, introduced by Anthropic in 2024, that gives AI tools a common way to connect to other software. Without a shared standard, every AI tool would need its own custom integration for every service it wanted to work with. MCP replaces that with one protocol that any compatible tool can use.

A helpful way to picture it is a USB-C port. Just as USB-C lets you plug many different devices into one kind of socket, MCP lets many different AI tools plug into the same services. Bubble provides an MCP server, which means AI tools that support MCP can connect to Bubble and work with your apps.

When people talk about "an MCP," they usually mean an MCP server: the connection point a service like Bubble provides for AI tools to plug into.

<details>

<summary>What is an AI agent?</summary>

An AI agent is an AI tool that can take actions, not just answer questions. Instead of only writing a reply, an agent can use tools, like the ones an MCP server provides, to carry out a task step by step. When you ask an agent connected to Bubble to add a page to your app, it works out what's needed and makes the changes itself.

</details>

<details>

<summary>MCP clients and servers</summary>

An MCP connection has two sides:

| Side       | What it is                                                                    | Example                    |
| ---------- | ----------------------------------------------------------------------------- | -------------------------- |
| MCP client | The AI tool you work in. It sends requests on your behalf.                    | Claude, Claude Code, Codex |
| MCP server | The service the AI tool connects to. It offers a set of tools the AI can use. | Bubble's MCP server        |

The client and server communicate using the MCP standard, so a client that supports MCP can connect to any MCP server.

</details>

## Connecting an external AI agent to Bubble

Every tool follows the same basic pattern: you add Bubble's MCP server to your AI agent, then sign in to your Bubble account in the browser to give the tool access.

{% hint style="info" %}
Bubble's MCP server URL is:

`https://mcp.bubble.io/mcp`
{% endhint %}

{% hint style="warning" %}
Note: Bubble's MCP server uses CIMD (Client ID Metadata Documents), a newer sign-in standard. Some tools, like Cursor and Composio, don't support it yet. We're working on support for these tools.
{% endhint %}

### **Claude**

{% stepper %}
{% step %}

#### Open your connector settings

In Claude, go to **Customize** and select **Connectors**.
{% endstep %}

{% step %}

#### Find Bubble MCP

Click **+** and search for *Bubble MCP*.
{% endstep %}

{% step %}

#### Connect

Click **Connect**.
{% endstep %}

{% step %}

#### Sign in to Bubble

Sign in to your Bubble account and approve the requested permissions.
{% endstep %}

{% step %}

#### Turn it on in a chat

In a chat, click **+**, select **Connectors**, and toggle **Bubble MCP** on.
{% endstep %}
{% endstepper %}

***

### **Claude Code**

{% stepper %}
{% step %}

#### Add the server

Run this command in your terminal:

```bash
claude mcp add --transport http --scope user bubble https://mcp.bubble.io/mcp
```

The `--scope user` part makes Bubble available in all your Claude Code projects, not just the one you're in.
{% endstep %}

{% step %}

#### Sign in to Bubble

Open Claude Code, type `/mcp`, and select *bubble* from the list. Choose to authenticate, and a browser window opens where you sign in to your Bubble account and give Claude Code access.
{% endstep %}
{% endstepper %}

<details>

<summary>Alternative: Add Bubble to a single project</summary>

If you only want Bubble available in one project, or want to share the setup with others working on it, add this to the `.mcp.json` file in the project's root folder:

```json
{
  "mcpServers": {
    "bubble": {
      "type": "http",
      "url": "https://mcp.bubble.io/mcp"
    }
  }
}
```

Then open Claude Code in that project, type `/mcp`, and select *bubble* to sign in.

</details>

***

### ChatGPT

{% stepper %}
{% step %}

#### Turn on developer mode

**Personal account**: Open **Settings**, go to **Security and login**, and turn on **Developer mode**.

**Enterprise/Edu workspace**: A workspace **admin** must **enable** **Developer mode** access.
{% endstep %}

{% step %}

#### Create a custom MCP server

Go to **Plugins**, click the **+** next to the search bar, and select **Create custom MCP server**, then **Create MCP app**.
{% endstep %}

{% step %}

#### Fill in the server details

* Under *Name*, enter `Bubble`.
* Under *Connection*, keep *Server URL* selected and paste Bubble's MCP server URL: `https://mcp.bubble.io/mcp`
* Leave *Authentication* set to *OAuth*.
  {% endstep %}

{% step %}

#### Create the app

Check *I understand and want to continue*, then click **Create**.
{% endstep %}

{% step %}

#### Sign in to Bubble

When prompted, sign in to your Bubble account and give ChatGPT access.
{% endstep %}
{% endstepper %}

***

### **Codex**

<details>

<summary>What is a terminal?</summary>

A terminal is an app on your computer where you type text commands instead of clicking buttons. On a Mac it's called Terminal, and on Windows you can use PowerShell or Command Prompt. You only need it here to add the server, and you can copy and paste the commands below.

</details>

{% stepper %}
{% step %}

#### Add the server

Run this command in your terminal:

```bash
codex mcp add bubble --url https://mcp.bubble.io/mcp
```

{% endstep %}

{% step %}

#### Sign in to Bubble

Run this command:

```bash
codex mcp login bubble
```

A browser window opens where you sign in to your Bubble account and give Codex access.
{% endstep %}
{% endstepper %}

***

### VS Code and GitHub Copilot

{% stepper %}
{% step %}

#### Add the server

Add this to the `.vscode/mcp.json` file in your project:

```json
{
  "servers": {
    "bubble": {
      "type": "http",
      "url": "https://mcp.bubble.io/mcp"
    }
  }
}
```

{% endstep %}

{% step %}

#### Start the server and sign in

Click **Start** above the `bubble` entry in the file, then sign in to your Bubble account when prompted.
{% endstep %}
{% endstepper %}

{% hint style="info" %}
If your configuration file already lists other MCP servers, add the `bubble` entry alongside them inside `servers`, rather than replacing what's there.
{% endhint %}

## Why connect an external AI agent to Bubble?

Bubble AI and the MCP server are two ways to build with AI on Bubble, and both build the same kind of app. The difference is where you work and which AI does the work. Here's why you might choose to connect an outside AI tool.

### Work in the agent you already use

If you already spend your day in Claude Code, Codex, or another AI agent, you can build and edit your Bubble apps from there, without switching back and forth. Your conversations and your way of working stay where they are.

### Choose your AI model

Most AI tools let you pick from one or more AI models. With the MCP server, you decide which model builds your app, and you can switch whenever a different model suits you better.

<details>

<summary>What's the difference between an AI tool and an AI model?</summary>

The AI model is the underlying intelligence that reads your prompt and decides what to do. The AI tool is the app you use to talk to it, like Claude Code or Cursor, which adds its own instructions and ways of working on top of the model. Together, the tool and the model shape how your app gets built.

</details>

### More variety in design

Every AI agent and model tends to build in its own recognizable way, and that includes design. Given the same prompt, two agents can make different choices about layout, spacing, color, and typography. While styles can differ a lot based on the prompt, Bubble AI may build your app in its own "fingerprint" style, while apps built through the MCP server take on the style of whichever agent and model you use.

That opens up more variety. If one agent's typical look doesn't match what you have in mind, another may come closer, and you can refine every detail in the visual editor afterward.

### Bring in context from your other tools

Your AI agent may also be connected to other MCP servers, like your documents, design files, project notes or external design resources like [Mobbin](https://mobbin.com/mcp). Because it can read from those at the same time, it can use that context while it builds in Bubble. For example, it could draft a page based on a spec you've written somewhere else.

### Keep full control in the visual editor

Whatever the AI tool builds, it builds with Bubble's own elements, workflows, and data types, so there's no generated code to read. You can open the app in the editor, see exactly how it works, and change anything yourself, whether the work started in Bubble or in another tool.

### Usage runs through your AI provider

The MCP server doesn't use Bubble AI, so the AI work doesn't count toward your Bubble AI credits usage. It counts toward your account with the AI provider you're using instead, such as your Claude plan.

## How the MCP server compares to Bubble AI

<table><thead><tr><th width="183.234375"></th><th>Bubble AI</th><th>MCP server</th></tr></thead><tbody><tr><td>Where you work</td><td>In the Bubble editor</td><td>In your own AI tool, like Claude, Claude Code or Codex</td></tr><tr><td>AI model</td><td>Bubble AI</td><td>The model you choose in your AI tool</td></tr><tr><td>AI usage</td><td>Counts toward your Bubble AI usage</td><td>Counts toward your account with your AI provider</td></tr><tr><td>What it builds</td><td>A Bubble app you can edit visually</td><td>A Bubble app you can edit visually</td></tr></tbody></table>

You can use both: Bubble AI while you work in the editor, and the MCP server when you want to work from another agent or try a different model.

## What you can do with the MCP server

Once it's connected, your third-party AI agent can work on most parts of your app. Common uses include:

<table><thead><tr><th width="246.2421875">Use</th><th>What it looks like</th></tr></thead><tbody><tr><td>Create a new app</td><td>Describe the app you want, and the AI agent builds it in your Bubble account.</td></tr><tr><td>Edit an existing app</td><td>Add pages, elements, workflows, and data types, or change what's already there.</td></tr><tr><td>Debug</td><td>Ask the AI agent to find out why something isn't working, and fix it.</td></tr><tr><td>Refactor</td><td>Ask it to reorganize or simplify parts of your app without changing what they do.</td></tr><tr><td>Add sample data</td><td>Fill your database with realistic test records, so you can see how your app looks and behaves with data in it.</td></tr><tr><td>Set up automations and connect to other MCP services</td><td>Create backend workflows that run on a schedule or when data changes, set up API calls to external services, and use information from other MCP servers you've connected, like a spec in your documents.</td></tr></tbody></table>

<details>

<summary>What does refactoring mean?</summary>

Refactoring means changing how something is built without changing what it does. In a Bubble app, that could mean combining workflows that do the same thing, renaming elements so they're easier to find, or tidying up a page's structure. Your users won't notice a difference, but the app becomes easier to maintain.

</details>

### Complete list of tools

Your third-party AI agent chooses which tools to use based on your prompt, so you don't need to call them yourself. The tables below list everything Bubble's MCP server can do, grouped by category.

| Category                                                      | Examples                                                                  |
| ------------------------------------------------------------- | ------------------------------------------------------------------------- |
| [Apps and account](#apps-and-account)                         | `list_apps`, `create_app`, `check_app_name`, `whoami`                     |
| [Exploring an app](#exploring-an-app)                         | `get_app_outline`, `get_node`, `get_pages`, `list_types`                  |
| [Pages and elements](#pages-and-elements)                     | `create_page`, `create_element`, `move_element`, `set_element_properties` |
| [Styles and variables](#styles-and-variables)                 | `create_style`, `assign_style`, `create_color_token`                      |
| [Workflows](#workflows)                                       | `create_event`, `create_action`, `reorder_actions`                        |
| [Expressions](#expressions)                                   | `validate_expression`, `create_global_expression`                         |
| [Data types and privacy](#data-types-and-privacy)             | `create_data_type`, `create_field`, `create_privacy_rule`                 |
| [Records and files](#records-and-files)                       | `create_thing`, `search_things`, `update_thing`, `delete_thing`           |
| [Option sets](#option-sets)                                   | `create_option_set`, `create_option`                                      |
| [API Connector](#api-connector)                               | `create_api_collection`, `create_api_call`                                |
| [Plugins](#plugins)                                           | `search_plugins`, `install_plugin`                                        |
| [Testing, preview, and issues](#testing-preview-and-issues)   | `get_preview_link`, `check_app_issues`, `create_test_cases`               |
| [Changes, undo, and savepoints](#changes-undo-and-savepoints) | `apply_changes`, `undo`, `create_savepoint`, `restore_savepoint`          |

### Tool details

<details>

<summary>Apps and account</summary>

| Tool             | What it does                                                                |
| ---------------- | --------------------------------------------------------------------------- |
| `list_apps`      | Lists the Bubble apps you have access to, including apps shared with you.   |
| `check_app_name` | Checks whether an app name is available. Checking doesn't reserve the name. |
| `create_app`     | Creates a new app on the Free plan, owned by you, for web, mobile, or both. |
| `whoami`         | Shows which Bubble account the current session is signed in as.             |

</details>

<details>

<summary>Exploring an app</summary>

| Tool                      | What it does                                                                                                                                              |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `get_app_outline`         | Lists everything in the app: pages, mobile views, reusable elements, backend workflows, data types, option sets, styles, global expressions, and plugins. |
| `get_node`                | Describes one part of the app, such as an element, page, workflow, or data type, the way the editor shows it.                                             |
| `get_pages`               | Lists the app's pages, with when each was last changed.                                                                                                   |
| `get_mobile_views`        | Lists the app's mobile views, with when each was last changed.                                                                                            |
| `list_element_types`      | Lists the element types available in the app, including elements from installed plugins.                                                                  |
| `get_element_type_fields` | Lists the properties available for an element type, with their defaults and options.                                                                      |
| `list_types`              | Lists the types available in the app, including built-in types, data types, option sets, and API call responses.                                          |
| `get_app_plan_context`    | Shows what the app's plan allows, such as API access, scheduled workflows, and database triggers.                                                         |

</details>

<details>

<summary>Pages and elements</summary>

| Tool                     | What it does                                                                                          |
| ------------------------ | ----------------------------------------------------------------------------------------------------- |
| `create_page`            | Creates a new page, or copies an existing page with its elements and workflows.                       |
| `create_mobile_view`     | Creates a new mobile view. The app needs to include a mobile app.                                     |
| `create_reusable`        | Creates a new reusable element.                                                                       |
| `create_element`         | Adds an element to a page, mobile view, reusable element, or container.                               |
| `set_element_properties` | Changes the properties of an element, page, mobile view, or reusable element.                         |
| `move_element`           | Moves an element to a different container on the same page or reusable element.                       |
| `rename_node`            | Renames an element, page, reusable element, mobile view, or workflow event or action.                 |
| `delete_element`         | Deletes an element and everything inside it, along with its workflows unless you choose to keep them. |
| `create_conditional`     | Adds a conditional to an element.                                                                     |
| `reorder_conditionals`   | Changes the order of an element's conditionals. When several apply at once, the last one wins.        |
| `delete_conditional`     | Removes a conditional from an element.                                                                |
| `set_transitions`        | Sets an element's transitions, replacing any existing ones.                                           |
| `create_custom_state`    | Adds a custom state to an element, page, or reusable element.                                         |
| `update_custom_state`    | Changes a custom state's name, type, list setting, or default value.                                  |
| `delete_custom_state`    | Deletes a custom state.                                                                               |

</details>

<details>

<summary>Styles and variables</summary>

| Tool                 | What it does                                                                              |
| -------------------- | ----------------------------------------------------------------------------------------- |
| `create_style`       | Creates a new style for an element type.                                                  |
| `update_style`       | Renames a style or changes its values. Every element using the style updates too.         |
| `assign_style`       | Applies a style to an element or reusable element.                                        |
| `detach_style`       | Removes a style from an element while keeping its current appearance.                     |
| `set_default_style`  | Makes a style the default for new elements of its type. Existing elements aren't changed. |
| `delete_style`       | Deletes a style. Elements that used it fall back to their own values.                     |
| `create_color_token` | Creates a color variable.                                                                 |
| `update_color_token` | Changes a color variable. Everything that uses it updates too.                            |
| `create_font_token`  | Creates a font variable.                                                                  |
| `update_font_token`  | Changes a font variable. Everything that uses it updates too.                             |

</details>

<details>

<summary>Workflows</summary>

| Tool                           | What it does                                                                                       |
| ------------------------------ | -------------------------------------------------------------------------------------------------- |
| `list_event_types`             | Lists the workflow events available on a page, mobile view, reusable element, or the backend.      |
| `list_action_types`            | Lists the workflow actions available, with their properties.                                       |
| `create_event`                 | Creates a workflow event, including backend workflow events.                                       |
| `create_action`                | Adds an action to a workflow.                                                                      |
| `set_workflow_item_properties` | Changes the properties of an existing event or action.                                             |
| `change_workflow_item_type`    | Changes an event or action to a different type, keeping the properties both types share.           |
| `reorder_actions`              | Changes the order of the actions in a workflow.                                                    |
| `delete_action`                | Deletes an action from a workflow.                                                                 |
| `delete_event`                 | Deletes a workflow event and all of its actions.                                                   |
| `set_workflow_api_enabled`     | Turns the Workflow API on or off. It needs to be on before backend workflow events can be created. |

</details>

<details>

<summary>Expressions</summary>

| Tool                        | What it does                                                                       |
| --------------------------- | ---------------------------------------------------------------------------------- |
| `get_expression_vocabulary` | Lists the data sources and operators available for building dynamic expressions.   |
| `validate_expression`       | Checks whether an expression is valid before it's used, without changing anything. |
| `create_global_expression`  | Creates a reusable global expression.                                              |
| `update_global_expression`  | Changes a global expression's name, parameters, or expression.                     |
| `delete_global_expression`  | Deletes a global expression. Places that still use it are flagged as issues.       |

</details>

<details>

<summary>Data types and privacy</summary>

| Tool                  | What it does                                                                                       |
| --------------------- | -------------------------------------------------------------------------------------------------- |
| `create_data_type`    | Creates a data type, optionally with fields.                                                       |
| `delete_data_type`    | Deletes a data type, which you can restore in the editor. The built-in User type can't be deleted. |
| `create_field`        | Adds a field to a data type, including the User type.                                              |
| `modify_field`        | Renames a field. A field's type can't be changed this way.                                         |
| `delete_field`        | Deletes a field, which you can restore in the editor.                                              |
| `create_privacy_rule` | Adds a privacy rule to a data type.                                                                |
| `modify_privacy_rule` | Changes a privacy rule's name, condition, or permissions.                                          |
| `delete_privacy_rule` | Deletes a privacy rule. The default rule for everyone else can't be deleted, only restricted.      |

</details>

<details>

<summary>Records and files</summary>

The record tools only work in your app's development version, and only for data types an admin has given the AI tool access to.

| Tool                      | What it does                                                                       |
| ------------------------- | ---------------------------------------------------------------------------------- |
| `grant_agent_data_access` | Gives the AI tool access to the records of specific data types. Requires an admin. |
| `get_app_data_context`    | Lists sample users the AI tool can act as when working with your app's data.       |
| `search_things`           | Searches the records of one data type.                                             |
| `get_thing`               | Reads one record.                                                                  |
| `create_thing`            | Creates one record.                                                                |
| `bulk_create_things`      | Creates many records of one data type at once.                                     |
| `update_thing`            | Changes some fields on one record, leaving the rest as they are.                   |
| `delete_thing`            | Deletes one record. This can't be undone.                                          |
| `upload_sample_data`      | Adds sample records to the app, so you can see how it works with data in it.       |
| `upload_image_by_url`     | Uploads an image from a URL to the app's file storage.                             |

</details>

<details>

<summary>Option sets</summary>

| Tool                      | What it does                        |
| ------------------------- | ----------------------------------- |
| `create_option_set`       | Creates an option set.              |
| `create_option_attribute` | Adds an attribute to an option set. |
| `create_option`           | Adds an option to an option set.    |

</details>

<details>

<summary>API Connector</summary>

| Tool                    | What it does                                                                            |
| ----------------------- | --------------------------------------------------------------------------------------- |
| `create_api_collection` | Creates an API Connector collection, and installs the API Connector if needed.          |
| `update_api_collection` | Changes a collection's settings, such as shared headers and authentication.             |
| `delete_api_collection` | Deletes a collection and all of its calls.                                              |
| `create_api_call`       | Creates an API call. You initialize it in the editor before using its response.         |
| `update_api_call`       | Changes an API call. Changes to the request need to be initialized again in the editor. |
| `delete_api_call`       | Deletes an API call.                                                                    |

</details>

<details>

<summary>Plugins</summary>

| Tool                         | What it does                                                                   |
| ---------------------------- | ------------------------------------------------------------------------------ |
| `search_plugins`             | Searches the plugin marketplace.                                               |
| `get_plugin_detail`          | Shows a plugin's description and the elements, actions, and API calls it adds. |
| `get_plugin_install_check`   | Checks whether a plugin can be installed in the app.                           |
| `install_plugin`             | Installs a plugin. Paid plugins need to be purchased first.                    |
| `get_plugin_uninstall_check` | Checks whether a plugin can be uninstalled, and what would stop working.       |
| `uninstall_plugin`           | Uninstalls a plugin. Anything that used it stops working.                      |

</details>

<details>

<summary>Testing, preview, and issues</summary>

| Tool                               | What it does                                                                                      |
| ---------------------------------- | ------------------------------------------------------------------------------------------------- |
| `get_preview_link`                 | Returns a preview link for a page, mobile view, or reusable element.                              |
| `get_issues`                       | Lists the issues currently shown in the editor's issue checker.                                   |
| `check_app_issues`                 | Runs a fresh issue check across the whole app.                                                    |
| `check_node_issues`                | Runs a fresh issue check on one part of the app, such as a page with its elements and workflows.  |
| `create_test_cases`                | Adds descriptions of functional tests to the app. This doesn't run them.                          |
| `get_test_cases`                   | Lists the app's functional test cases.                                                            |
| `get_debug_mode_session`           | Creates a one-time session for opening the app in debug mode.                                     |
| `get_app_user_impersonation_token` | Creates a temporary sign-in for one of your app's users, so you can preview the app as that user. |

</details>

<details>

<summary>Changes, undo, and savepoints</summary>

| Tool                        | What it does                                                                                                     |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| `apply_changes`             | Makes several changes in one batch. If any change fails, none of them are applied.                               |
| `list_pending_undo`         | Lists recent changes that can be undone or redone.                                                               |
| `undo`                      | Undoes a change, or every change from one conversation. It can also redo a change you undid.                     |
| `create_savepoint`          | Saves a restore point for the app that you can return to later.                                                  |
| `restore_savepoint`         | Restores the app to a savepoint, replacing any changes made since. How far back you can go depends on your plan. |
| `acknowledge_undo_recovery` | Clears a blocked undo entry once any needed repairs are done.                                                    |

</details>

### Current limitations

A few things aren't available through the MCP server at the moment:

* Merging branches (but you can specify which branch you want the agent to work on)
* Deploying your app
* OAuth2 setup stays in the editor.
* Paid plugins have to be bought before the AI tool can install them.

You can still do all of these yourself in the Bubble editor.

{% hint style="info" %}
Since the MCP server can't deploy your app, the changes it makes don't reach your live app until you deploy them yourself. That gives you a chance to review everything first.
{% endhint %}

## Permissions and plans

The MCP server acts as your logged in Bubble account user. When your AI tool makes changes, it uses your Bubble account, so it can only do what you're allowed to do.

Two things follow from this:

* **Your permissions apply.** If you're a collaborator on an app, the AI tool has the same access you do, and no more. Each collaborator who connects their own AI tool works within their own permissions.
* **Your plan applies.** Features that require a certain plan still require it. For example, if your app's plan doesn't include backend workflows, the AI tool can't create them either.

### Access to your app's data

When you connect your AI tool, you're asked to approve what it can do with your app's data. The AI tool can read and make changes to records in your development database, but it can only read your live database:

<table><thead><tr><th width="149.32421875">Database</th><th>Read</th><th>Write</th></tr></thead><tbody><tr><td>Development</td><td>Yes</td><td>Yes</td></tr><tr><td>Live</td><td>No</td><td>No</td></tr></tbody></table>

This means the AI tool can add sample data, update records, and help you debug in development, but it can't change the data your users rely on in your live app.

The AI tool can also only reach the data types an admin has given it access to. Data types without access stay out of reach, even within the scopes above.

{% hint style="warning" %}
Records the AI tool reads are sent to the AI provider you're using, such as Anthropic for Claude. If your live database holds sensitive information, think about which data types you give the AI tool access to.
{% endhint %}

## Working with the MCP server

Once you're connected, you work with Bubble the same way you'd work with anything else in your AI tool: describe what you want in plain language. The AI tool decides which of the MCP server's tools to use, makes the changes in your app, and returns a preview link so you can see the result.

### Example prompts

Here are a few prompts to get you started:

```
Create a new Bubble app for a book club, where members can suggest books and vote on what to read next.
```

```
In my recipe app, add a page where users can see all the recipes they've saved.
```

```
The Save button on my profile page doesn't update the user's name. Find out why and fix it.
```

```
Add 20 sample products with names, prices, and descriptions to my store app.
```

```
Find workflows on my dashboard page that do the same thing, and combine them.
```

If you have more than one app, name the app you mean in your prompt, so the AI tool works on the right one.

### Reviewing changes

When the AI tool finishes, open the preview link or your app in the Bubble editor to review what it built. Since everything is visual, you can check each element, workflow, and data type, and adjust anything by hand or with another prompt.&#x20;

You can also look at the change log to get an overview of the changes made.

{% hint style="warning" %}
The AI tool makes real changes to your app, using your permissions. If you're trying the MCP server for the first time, consider starting with a test app, so you can see how it works before using it on an app you care about.
{% endhint %}

## Undoing changes

#### Undoing changes

Changes the AI tool makes don't go into the Bubble editor's undo history, so pressing undo in the editor won't reverse them. You have two ways to undo:

<table><thead><tr><th width="206.890625">Method</th><th>How it works</th></tr></thead><tbody><tr><td>Ask the AI tool</td><td>Ask it to undo, in plain language.</td></tr><tr><td>Restore a savepoint</td><td><strong>Ask the AI tool to create a savepoint before a big change.</strong> If you don't like the result, ask it to restore that savepoint. This replaces every change made since, including any you made yourself in the editor.</td></tr></tbody></table>

A single prompt can result in several changes, so if you want to roll back everything from one request, it's often easiest to ask for that directly. For example:

```
Undo everything you changed in this conversation.
```

```
Create a savepoint before you start, then rebuild the checkout page.
```

{% hint style="warning" %}
Some changes can't be undone. Records the AI tool deletes from your database can't be restored by undoing. How far back you can restore a savepoint depends on your plan.
{% endhint %}

## FAQ: Bubble MCP server

<details>

<summary>Does the MCP server use Bubble AI?</summary>

No. The MCP server doesn't use Bubble AI or the Bubble AI Agent. The AI work is done by the AI tool and model you connect, such as Claude.

</details>

<details>

<summary>Does using the MCP server count toward my Bubble AI credits usage?</summary>

No. Since the AI work happens in your own AI tool, it counts toward your account with that AI provider instead.

</details>

<details>

<summary>Which AI tools can I connect?</summary>

You can connect Claude, Claude Code, ChatGPT, Codex, and VS Code with GitHub Copilot. Other AI tools can connect if they support MCP sign-in with CIMD. Tools like Cursor and Composio don't support it yet, but we are working on support for those tools.

</details>

<details>

<summary>Can the MCP server deploy my app?</summary>

No. Deploying, merging branches, and reading logs aren't available through the MCP server at the moment. You can do all three yourself in the Bubble editor.

</details>

<details>

<summary>Can collaborators use the MCP server?</summary>

Yes. Each collaborator connects their own AI tool, and the MCP server works within that collaborator's permissions on the app.

</details>

<details>

<summary>Can the AI tool do things my plan doesn't allow?</summary>

No. The MCP server acts as you, so your app's plan applies. If a feature requires a plan you don't have, the AI tool can't use it either.

</details>

<details>

<summary>Do I need to know how to code?</summary>

No. You describe what you want in plain language, and everything the AI tool builds is visual. Connecting Claude Code involves typing one command into a terminal, but you can copy and paste it as written.

</details>