Integration · Automate and collaborate

Bubble and Meteor AI agents

Connect Bubble to a WhatsApp Met: review and edit your app's development version, find issues and load test data with the official MCP.

Book a demo See every integration

How does Bubble connect to Meteor?

With the Bubble ready connector, your Met works on your Bubble apps through the official MCP server, authorized once with your account. It walks through the whole app, adds pages, elements, workflows and data types, changes properties and styles, loads test records and runs Bubble's issue checker, and returns a preview link for you to review. Everything happens in the development version: the connector does not deploy or touch the live database, so the change reaches your users only when you deploy it in the editor. Installing plugins, restoring savepoints and changing privacy rules start switched off.

What it automates

What a Meteor Met does with Bubble

Ask for a change in the app on WhatsApp

You ask the Met to add a field to the sign up form. It finds the page, creates the element, adjusts its properties and sends you the preview link to review.

Check for issues before deploying

The Met runs Bubble's issue checker across the whole app or on one page and sums up what is wrong, so you fix it before going to production.

Load test data

The Met adds sample records to the development database so you see how the app behaves with data, without touching the database your customers use.

Go back if something went wrong

Before a big change, the Met saves a restore point. If you do not like the result, it undoes the changes from the conversation.

42 tools

Everything your Met can ask Bubble for

Each one is a real action in the connector. You can switch off the ones you would rather it never used.

Tool	What it does
`whoami`	Shows which Bubble account the session is signed in as.
`list_apps`	Lists the Bubble apps you can access, including those shared with you.
`check_app_name`	Checks whether an app name is available, without reserving it.
`create_app`	Creates a new app on the Free plan, owned by you, for web, mobile or both.
`get_app_outline`	Lists everything in the app, from pages and workflows to data types, styles and plugins.
`get_node`	Describes one part of the app, such as an element, a page or a workflow, the way the editor shows it.
`get_pages`	Lists the app's pages with when each one was last changed.
`list_types`	Lists the types available in the app, including data types and API responses.
`get_app_plan_context`	Shows what the app's plan allows, such as API access or scheduled workflows.
`create_page`	Creates a new page, or copies an existing one with its elements and workflows.
`create_element`	Adds an element to a page, a mobile view, a reusable element or a container.
`set_element_properties`	Changes the properties of an element, a page or a view.
`move_element`	Moves an element to another container on the same page.
`rename_node`	Renames an element, a page, a view or a workflow step.
`delete_element`	Deletes an element with everything inside it. Starts switched off.
`create_style`	Creates a new style for an element type.
`update_color_token`	Changes a color variable; everything that uses it changes too.
`create_event`	Creates a workflow event, including backend workflow events.
`create_action`	Adds an action to a workflow.
`create_data_type`	Creates a data type, with fields when asked.
`create_field`	Adds a field to a data type, including the User type.
`create_privacy_rule`	Adds a privacy rule to a data type.
`modify_privacy_rule`	Changes a privacy rule's name, condition or permissions. Starts switched off.
`grant_agent_data_access`	Gives the connector access to the records of specific data types; needs an admin. Starts switched off.
`search_things`	Searches the records of a data type in the development database.
`get_thing`	Reads one record from the development database.
`create_thing`	Creates a record in the development database.
`update_thing`	Changes some fields on a record and leaves the rest as they are.
`delete_thing`	Deletes a record; this cannot be undone. Starts switched off.
`upload_sample_data`	Adds sample records to see how the app works with data.
`search_plugins`	Searches Bubble's plugin marketplace.
`install_plugin`	Installs a plugin; paid ones must be bought first. Starts switched off.
`get_preview_link`	Returns a preview link for a page, a mobile view or an element.
`get_issues`	Lists the issues the editor's issue checker shows right now.
`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 workflows.
`create_test_cases`	Adds descriptions of functional tests to the app, without running them.
`list_pending_undo`	Lists recent changes that can be undone or redone.
`undo`	Undoes a change or every change from a conversation; it can also redo an undone one.
`create_savepoint`	Saves a restore point for the app to return to later.
`restore_savepoint`	Restores the app to a savepoint and replaces what was done since. Starts switched off.
`get_app_user_impersonation_token`	Creates a temporary sign in as one of the app's users to see it as them. Starts switched off.

The limits

What the Bubble integration does NOT do

We would rather say it here than have you find out during rollout.

It does not deploy your app. Changes stay in the development version and reach your users only when you deploy them in the Bubble editor.
It does not read or write the live database. It only works with the development database, and only with the data types an admin gave it access to.
It does not ask you for confirmation in the chat before changing the app. The admin chooses in Connections which actions stay on; deleting, installing plugins and restoring savepoints start switched off.
It does not read server logs or merge branches. Those tasks stay in the Bubble editor.
It does not do what your Bubble plan does not allow. The connector acts with your account, your permissions and the app's plan.

Before you start

What you need to connect Bubble

1

A Bubble account with your app

The Bubble account with access to the app, as owner or collaborator. The connector has the same permissions as your account, and according to Bubble it is free while in beta.
2

Connect it in Met

In Met, open Connections → Bubble → Connect. A Bubble window opens so you can sign in and approve what the connector can do with your app's data.
3

Decide which actions stay on

The workspace admin reviews the list of actions. Deleting, installing plugins, restoring savepoints, granting data access and changing privacy rules start switched off.

Frequently asked questions

Questions about Bubble and Meteor

No. The connector works on the development version and does not deploy. You review in the preview and deploy yourself from the Bubble editor.

Not the live database. It only reads and writes the development database, and only the data types an admin gave it access to.

Ask it to undo the changes from the conversation, or to go back to a restore point if the admin turned that action on. Records it deleted from the database do not come back by undoing.

According to Bubble, its MCP is free while in beta. Your Bubble plan still runs on your account; Meteor does not resell Bubble.

Step by step