The issue explorer (see Key terms) in the security dashboard (see Key terms) provides a detailed list of potential security vulnerabilities in your app. In this section, we'll break down each issue, offer suggested solutions, and provide further reading to help you address them.
You can see a short-form table of these issues, as well as the permissions needed to evaluate them, in the article section below:
Article section: The issue explorer issue list
Constrainable fields
Overview
When Find this in searches is enabled on a custom or Everyone else privacy rule (see Key terms), you can decide whether each field is viewable and whether it can be used as a constraint in searches.
Keep in mind that a field being non-viewable doesn't fully protect it. An attacker can still repeatedly run searches with carefully chosen constraints and piece together sensitive values from the results, even without ever seeing the field directly.
Purpose
This issue flags scenarios where Find this in searches is enabled, View is disabled, and Constraint is enabled. This combination is flagged because even though users can't see the field directly, they can still use it as a constraint in searches. By running repeated searches with different constraint values, an attacker can deduce the underlying data, reconstructing the field one piece at a time.
Trigger
This issue will be triggered if:
A sensitive field has Find this in searches enabled, View disabled, and Constraint enabled.
Solution
Before you make changes
When Constraint is unchecked for a field on a privacy rule, any search using that field as a constraint returns zero results for users subject to that rule. This applies to repeating groups (see Key terms), nested searches, and any other expression that references the field as a constraint.
As a result, the same search can work correctly for some user roles and silently return nothing for others. The steps below help you identify which searches are affected before you make any changes.
When it's safe to disable Constraint
When the privacy rule is unrelated to searches in your app: If none of the searches returned by the app search tool (see Key terms) depend on the rule in question, unchecking Constraint won't break anything.
For example, suppose your app has a privacy rule that applies to logged-out users, with Constraint enabled on the email field. If only logged-in users need to search by email, you can safely uncheck Constraint on the logged-out rule, since the search isn't relevant to those users anyway.
When the results are only used in contexts that ignore privacy rules: If the search results are only used in backend workflows (see Key terms) that ignore privacy rules, database triggers (see Key terms), or custom backend workflows triggered by endpoints that ignore privacy rules, you can uncheck Constraint without affecting them.
When the privacy rule is related to your searches
If the rule does relate to searches, you have two options:
Leave the configuration as is and accept the risk. An attacker may be able to apply clever constraints across repeated searches and piece together fields you consider sensitive.
Refactor your database schema so the vulnerable field doesn't contain sensitive data in the first place.
Finding the right balance
Searching by constraints is a natural part of how many apps work, and this issue shouldn't be treated as a hard rule to avoid at all costs. There's some risk that users can combine multiple searches with different constraints to infer information about data they can't see directly. Whether that's a meaningful concern depends on your specific app, the sensitivity of the data, and how realistic the attack scenario is in practice.
Database exposure risks
Overview
Even with privacy rules (see Key terms) in place, data “leaks” can occur if the rules are not properly configured. Various scenarios can lead to unintentional exposure of data, and while these might seem like rare corner cases, they are more common than you might expect.
This issue is a warning that the security check was able to access data marked as sensitive while logged out, highlighting a potential gap in your app’s privacy configuration. It's based on identifying exposed data during a logged-out state, rather than on checking your privacy rules directly.
Purpose
The purpose of flagging this issue is to indicate that a logged-out user may have access to data marked as sensitive, potentially exposing information that should be protected.
Trigger
This issue will be triggered if:
A data type (see Key terms) marked as sensitive has been accessed by Bubble's security check while logged out, suggesting a potential vulnerability in your app’s privacy rules.
Solution
This issue highlights that sensitive data is accessible to logged-out users, but it isn't tied to any specific privacy rule misconfiguration. While we provide potential solutions in this section, not all scenarios may be covered. We strongly recommend reviewing our comprehensive guide on privacy rules to help identify and resolve the issue.
Possible causes
Privacy rules that are always true: Be mindful of privacy rules that always return a true value. As a very basic example,
Current user is current userwould always return a true value.Not taking empty values into account: Many privacy rules work by comparing a field on a data type to a field on the user. For instance, you might create a rule like
This Task’s Company is Current User’s Company. This means that only tasks belonging to the current user’s company are accessible.
However, for logged-out users, the Company field on the user is empty. If there are tasks in your database where the Company field is also empty, those tasks may become accessible to logged-out users (or logged-in users with an empty Company field). While this scenario should ideally not occur, it’s good practice to add an additional safeguard to your dynamic expression (see Key terms). For example:
This Task’s Company is Current User’s Company and Current User’s Company is not empty.
This extra step means tasks are only accessible when the user has a valid company assigned, reducing the risk of unintended exposure.
Not checking if the user is logged in: To add an additional layer of security, you can also check that the current user is actually logged in. Expanding on the example above, the privacy rule may look like this:
This Task’s Company is Current User’s Company and Current User’s Company is not empty and current user is logged in.
Troubleshooting
Data leaks only appear in one version of my app:
Privacy rules differ between the development and live versions of your app. To keep them consistent, deploy your app to make the development version live and synchronize the privacy rules.
Discrepancies between the databases in the live and development environments can also affect Bubble's ability to identify issues. For example, if your development version has an empty database, Bubble can't detect potential data leaks and won't flag this as an issue. It’s important to verify both versions to make sure your privacy rules and data are correctly aligned.
My issue is still not resolved. What can I do?
If the data leak issue persists even after synchronizing your privacy rules and deploying the app, here are a few additional steps you can take to resolve it:Run a fresh security test from the security dashboard (see Key terms).
To verify the data and get a visual overview of the data leaking from your app, we suggest running a privacy rules checker (see Key terms) test from the security dashboard.
Advanced: If you still can't find the solution to your problem, you can duplicate your app (including database content) and open the Data API (see Key terms) to see the leaking data and troubleshoot more easily.
Learn more
To learn more about how privacy rules work, check out the article below:
Article: Protecting data with privacy rules
Default username/password risks
Overview
Bubble allows you to secure the development version (see Key terms) of your app (commonly called version-test) with a username and password. However, if you use the default credentials, there is a risk that someone could gain unauthorized access to the development version simply by guessing them.
The default username and password are username and password.
Purpose
The purpose of flagging this issue is to remind you to change the default and set your own unique credentials instead.
Trigger
This issue will be triggered if:
The username and password for your app's development version are set to
usernameandpassword.
Solution
To solve this issue, do the following:
Navigate to Settings – General.
Look for Limit access to this app in run mode with a username and password under Privacy & Security.
Set a unique set of credentials.
Unrestricted iFrame embedding
Overview
Allowing your app to be rendered as an iframe introduces several security vulnerabilities because it exposes your app to manipulation by external websites. Here’s a breakdown of the potential risks:
Clickjacking
What it is: An attacker embeds your app in an iframe on their website, overlaying it with invisible elements or misleading content. Users may unknowingly interact with your app, such as clicking buttons or submitting forms, without realizing the consequences.
Impact: This can result in unauthorized actions, such as granting permissions, transferring funds, or exposing sensitive information.
Phishing
What it is: By embedding your app in an iframe, an attacker can create a page that mimics your app and tricks users into entering sensitive information, like login credentials.
Impact: Users may believe they are interacting with your app, unknowingly providing their data to malicious actors.
Malware distribution
What it is: An attacker uses an iframe to deliver malicious scripts or downloads through your app, taking advantage of the trust users place in your platform.
Impact: This can infect users’ devices, compromise their security, and damage your app’s reputation.
Content manipulation
What it is: When your app is embedded as an iframe, attackers can manipulate the surrounding content to misrepresent your app or context.
Impact: This can lead to misinformation or defamation, harming user trust.
Session hijacking
What it is: Attackers may use iframe embedding in combination with other vulnerabilities to capture session cookies or tokens.
Impact: This can give attackers unauthorized access to user accounts or sensitive data.
Purpose
The purpose of flagging this issue is to inform you that your app allows rendering as an iframe, which could expose it to vulnerabilities like the ones outlined above.
Trigger
This issue will be triggered if:
The Allow to render the app in a frame/iframe (X-Frame-Options) option is enabled in your app's settings.
Solution
Similar to other potential vulnerabilities, allowing iframe rendering is not inherently harmful. However, if you aren't actively using this feature or are unsure of its purpose, we recommend disabling it to minimize the risk of vulnerabilities like those outlined in the overview.
Solution
Navigate to Settings – General.
Scroll to the option Allow to render the app in a frame/iframe (X-Frame-Options).
Set it to Block all frames.
Missing privacy rules
Overview
If a specific data type (see Key terms) is not meant to be public, you need to define privacy rules (see Key terms) to protect it. Bubble automatically identifies data types that don't have privacy rules set up, based on:
Fields that are defined as sensitive by Bubble's prediction model, or
Fields that you have manually set to sensitive
You can read more about how to set field sensitivity in the article below:
Article: Test settings
Purpose
The purpose of flagging this issue is to identify data types that have sensitive fields but aren't protected by privacy rules.
Trigger
This issue will be triggered if:
A sensitive data type has no privacy rules defined.
A data type is considered sensitive if it has been marked as such either by Bubble's prediction model or through manual designation.
You can read more about how to manually mark data types in the article below:
Article: Database ratings
Solution
We strongly recommend setting up privacy rules for all sensitive data types.
Solution 1: Set up privacy rules
Navigate to Data – Privacy.
Locate the relevant data type.
Define one or more privacy rules.
Solution 2: Change the rating of the data type
You can update the rating of the data type to inform the security dashboard that it does not contain sensitive information. See the article below for more information about how to change database ratings.
Learn more
To learn more about how to protect your database with privacy rules, see the article below:
Article: Protecting data with privacy rules
To learn more about how to mark data types as safe or sensitive:
Article: Database ratings
Public Bubble editor issue
Overview
Bubble provides the option to open your app editor to other users, allowing them to view and/or edit your app. This feature can be helpful for showcasing the editor publicly or collaborating with others to resolve specific issues.
However, granting open access to your app editor poses a significant security risk. It provides unrestricted access to all aspects of your app, including sensitive data, workflows, and settings, which can expose your app to potential vulnerabilities or misuse.
Purpose
The purpose of flagging this issue is to make you aware that your app allows anyone to view and/or edit the app.
Trigger
This issue will be triggered if:
The Define who can see and modify the app editor setting in your app's general settings is not set to Private app.
Solution
We strongly advise using this setting with caution, since it gives a very broad access level to all users who know the URL of your app.
Solution
Go to Settings – General.
Locate the Define who can see and modify the app editor setting under Privacy & Security.
Set it to Private app.
If you want to collaborate with other users in your app without opening the editor up for anyone, you can consider using the collaborator (see Key terms) features instead (see below).
Learn more
To learn more about how you can collaborate with other users when building your app, see the article below:
Article: Collaborators
Publicly accessible file uploaders
Overview
Just like the data in your database, uploaded files can be secured using privacy rules (see Key terms). These rules mean that even if someone obtains the file’s URL, they can't access the file unless the privacy rules explicitly grant them permission.
This needs to be set both in the privacy rules and on the relevant file uploader element (see Key terms), which makes it easy to miss.
Purpose
This issue is flagged to inform you that one or more file uploaders in your app are set to upload files without the protection of privacy rules, potentially leaving them accessible to unauthorized users.
Trigger
This issue will be triggered if:
One or more file uploader elements in your app don't have the Make this file private box checked.
Solution
If a file uploader element is intended to upload private files, follow these steps to secure the files:
Locate the element in the Design tab of the Bubble editor.
With the element selected, locate the Make this file private property in the element property editor (see Key terms) and make sure the box is checked.
Note that you need to set up your privacy rules to make sure that only the right users have access to the file. You can read more about this in the article listed below.
Learn more
To learn more about how to set up privacy rules, including protecting uploaded files, see the article below:
Article: Protecting data with privacy rules
Publicly accessible picture uploaders
Overview
Just like the data in your database, uploaded images can be secured using privacy rules (see Key terms). These rules mean that even if someone obtains the file’s URL, they can't access the file unless the privacy rules explicitly grant them permission.
This needs to be set both in the privacy rules and on the relevant picture uploader element (see Key terms), which makes it easy to miss.
Purpose
This issue is flagged to inform you that one or more picture uploaders in your app are set to upload files without the protection of privacy rules, potentially leaving them accessible to unauthorized users.
Trigger
This issue will be triggered if:
One or more picture uploader elements in your app don't have the Make this file private box checked.
Solution
If a picture uploader element is intended to upload private files, follow these steps to secure the files:
Locate the element in the Design tab of the Bubble editor.
With the element selected, locate the Make this file private property in the element property editor (see Key terms) and make sure the box is checked.
Note that you need to set up your privacy rules to make sure that only the right users have access to the file. You can read more about this in the article listed below.
Learn more
To learn more about how to set up privacy rules, including protecting uploaded files, see the article below:
Article: Protecting data with privacy rules
Publicly accessible sensitive fields
Overview
Privacy rules (see Key terms) consist of two types of rules:
Everyone else: The Everyone else rule defines what everyone who doesn't match any of the dynamic rules should have access to.
Privacy rules work in a way where the most “permissive” rule takes precedence over others. This means that if the Everyone else rule grants access to sensitive data in searches or fields, that data will be accessible to everyone, even if more restrictive dynamic rules are in place.
Purpose
This issue is flagged to highlight any instances where the Everyone else rule is set to allow users to View all fields. This setting could unintentionally expose sensitive data to unauthorized users, bypassing the more restrictive privacy rules you may have configured.
Trigger
This issue will be triggered if:
A data type contains at least one sensitive field.
The Everyone else privacy rule for this data type allows users to View all fields.
Solution
We strongly recommend setting up privacy rules for all sensitive data types.
Solution 1: Edit your privacy rules
Navigate to Data – Privacy.
Locate the relevant data type.
Make the necessary changes to the Everyone else rule.
Solution 2: Change the rating of the data type
You can update the rating of the data type to inform the security dashboard (see Key terms) that it does not contain sensitive information. See the article below for more information about how to change database ratings.
Learn more
To learn more about how to protect your database with privacy rules, see the article below:
Article: Protecting data with privacy rules
To learn more about how to mark data types as safe or sensitive:
Article: Test settings
Search privacy
Overview
Search privacy is a branch (see Key terms)-level application setting that controls how constraint permissions are enforced in privacy rules (see Key terms). Three modes are available:
Strict: The recommended setting, offering the highest level of security and control.
Automatic: A convenience and compatibility mode intended for apps where constraint permissions haven't been explicitly set.
Off: Reserved for troubleshooting and testing.
Core reference: Search privacy modes
Purpose
This security check highlights any instances where search privacy is not set to Strict. When this is the case, there may be fields in your app that are unintentionally constrainable.
Trigger
This issue will be triggered if:
The search privacy setting in one or more of your branches is set to Automatic or Off.
Solution
Solution 1: Set search privacy to Strict
Solution 2: Ignore the issue
If you're just testing your app or intentionally keeping your search privacy setting on Automatic or Off, you can ignore this issue in the security dashboard:
Find the Search privacy issue in the list.
Click the three dots and select one of the Ignore options.
Keep in mind that once the issue is ignored, Bubble won't flag it again.
Learn more
To learn more about how to protect data with privacy rules and the search privacy setting, see the articles below:
Article: Protecting data with privacy rules
Article section: Search privacy modes
Secure page protection
Overview
Bubble evaluates pages in two ways:
Public: Pages that can be accessed by anyone
Sensitive: Pages that can only be accessed by logged-in users
If a page is sensitive, it should contain an action that uses server-side redirection to redirect users to a different page, such as a front page or 404 page.
Purpose
The purpose of flagging this issue is to identify sensitive pages that don't have a proper redirect action.
Trigger
This issue will be triggered if:
A sensitive page has no 302 redirect action.
A page is considered sensitive if it has been marked as such either by Bubble's prediction model or through manual designation.
You can read more about how to evaluate specific pages in the article below:
Article section: Test settings | Selected pages and data types
Solution
We strongly recommend setting up a server-side redirect action on all pages that contain sensitive information.
Solution 1: Set up a server-side redirect
Navigate to the relevant page in the Bubble editor.
Add a Page is loaded or User is logged out event (see Key terms).
Set up a single Go to page (see Key terms) action that sends the user to another page.
Add a condition that checks whether the user is logged in on that action if needed.
If you add any other actions, the redirect will happen on the client side. To keep it server-side, the Go to page action must be the only action in the workflow.
If you add conditions not directly tied to the current user (see Key terms), like
Current user’s Role’s Admin is yes, where Role is a separate data type, the redirect will happen on the client side. To keep it server-side, use conditions based only on the current user, such asCurrent user is logged inorCurrent user’s admin is yes.
Solution 2: Change the rating of the page
You can update the rating of the page to inform Bubble that it does not contain sensitive information. See the article below for more information about how to change page ratings.
Learn more
To learn more about page security, read the article below:
Article: Page security
To learn more about how to mark pages as safe or sensitive:
Article: Page ratings
Sensitive data exposed in workflows
Overview
The Log the user in (see Key terms) action enables users to access your app by entering their email and password, typically through a login form where the user submits their credentials. However, Bubble also provides the option to pre-fill this data using static values, allowing you to specify the email, password, or both directly within the action.
This can lead to two vulnerabilities:
Unauthorized access: If the credentials (email and/or password) are hardcoded into the action, someone could potentially gain access to another user’s account, as the credentials are pre-filled in part or whole.
Data exposure: The static credentials entered in the action are stored in your app’s code, making them visible and potentially accessible to anyone who inspects the app’s code, posing a significant security risk.
Purpose
This issue is flagged to notify you that one or more Log the user in actions in your app have credentials pre-filled. This setup may pose a security risk, as it could lead to unauthorized access or expose sensitive information.
Trigger
This issue will be triggered if:
You have at least one action in your app where one or both of the login credentials are pre-filled with static values.
Solution
We strongly recommend against pre-filling login credentials in your app, as this practice can introduce significant security vulnerabilities, as outlined in the overview. Instead, allow users to enable the “Remember me” option, which stores their email in a cookie on their device after they log out. While there may be specific edge cases where pre-filling is considered, it’s generally unnecessary and poses avoidable risks.
Solution
Remove the pre-filled data: Get the login credentials from dynamic values entered in text input elements (see Key terms).
Remember the email: Consider enabling Bubble's built-in Remember the email feature. This stores the user’s email in a cookie on their device, so the email field is automatically pre-filled in the login form when they revisit the page on the same device, even if they have logged out.
Learn more
Article series: User accounts
Core reference: The Log the user in action
Core reference: The input element
Sensitive data in API URLs
Overview
By default, the endpoints specified in your API calls are not private and can be accessed by anyone who knows their location.
This may not pose a significant risk when working with third-party services that require additional authentication to access data. However, it can become a security concern when calling an endpoint that doesn't require authentication, as it may expose sensitive information or functionality.
Bubble uses AI to identify API endpoints that may be sensitive. However, it’s good practice to review all URL endpoints in your app, even those not flagged by Bubble, to make sure they don’t inadvertently expose sensitive information or functionality.
Purpose
The purpose of flagging this issue is to make you aware that Bubble's AI model has identified at least one URL endpoint that can be made more secure by hiding it.
Trigger
This issue will be triggered if:
Bubble's AI model has detected at least one potentially sensitive URL endpoint that is not concealed within a parameter.
Solution
There are two different solutions to this issue:
Solution 1: Hide the URL
To secure the URLs in your API calls, you can define the endpoint URL as a private parameter within the API call. This approach conceals the URL and helps keep it private, reducing the risk of exposure.
Here's an example:
Before:
In this example, we already have a parameter set up (param1), but the URL is not concealed.
After:
By replacing the URL with a parameter (in this case we've called it URL), you can store the URL as a hidden parameter instead. Make sure to check Private to hide the parameter. This way, it won't show up in your app's codebase.
The API Connector (see Key terms) only protects private parameters when the collection uses a secure authentication method, such as Private key in header. In a collection set to None or self-handled or OAuth2 User-Agent Flow, values marked Private are exposed.
Article section: Unsafe API call configuration
Solution 2: Ignore the issue
If you don't consider the URL sensitive, you can click the Ignore button in the issue explorer (see Key terms) to stop seeing it.
Insecure API documentation (Swagger)
Overview
Activating the Bubble API (see Key terms) allows external systems to interact with your app through various queries. Swagger provides a way for your API to describe itself automatically, enabling other systems to understand its structure and available queries.
While the Swagger file is not inherently a security vulnerability, hiding it is a form of obfuscation. Obfuscating the Swagger file can make it slightly more challenging for an unauthorized user to identify and access your API endpoints, adding an extra layer of complexity for potential intruders.
Article section: What is the Swagger specification?
Trigger
This issue will be triggered if:
Hide Swagger API documentation access is disabled.
Solution
As we mentioned in the overview, the Swagger documentation is not in itself a security vulnerability, but leaving it visible makes it easier for a potential intruder to identify your API endpoints.
If you have no use for it, or are unsure about what it does, we recommend hiding it.
Solution
Navigate to Settings – API.
Under Public API endpoints, check Hide Swagger API documentation access.
Learn more
To learn more about the Swagger documentation and what it's for, read the article section below:
Article section: What is the Swagger specification?
To learn more about the Bubble API in general, check out the article series on that subject:
Article series: The Bubble API
Temporary password exploits
Overview
The Assign a temp password to a user (see Key terms) action allows you to generate a new password for a user, enabling them to log in to their account and update it with a personal, unique password. However, if this action is executed client-side, there is a risk that the randomly generated password will be visible in the Network tab of your browser's Developer Tools.
Purpose
The purpose of flagging this issue is to highlight instances in your app where a randomly generated string is being used with the Assign a temp password to a user action. This setup could expose the temporary password to unauthorized access, increasing the risk of it being intercepted or stolen.
Trigger
This issue will be triggered if:
You have a client-side Assign a temp password to a user (see Key terms) action in your app.
Solution
In most scenarios, this action should be executed server-side, using the backend workflow (see Key terms) editor. This means the password is generated on the server (as opposed to on the user's device), and doesn't become visible in the browser's developer tools.
Solution
Move the Assign a temp password to a user action to the backend workflow editor (as an API workflow (see Key terms)).
When a new temp password is needed, call that API workflow from the frontend.
Learn more
To learn more about how to set up API workflows, see the article series below:
Article series: The Workflow API
Unprotected test environment
This issue only appears if you are on a paid plan, as the Free plan doesn't support password protecting version-test.
Overview
Bubble provides two distinct environments for your app: development (see Key terms) and live. The development environment is for previewing and testing your app as you build, allowing you to experiment and refine features. The live environment is what your end-users interact with: your fully deployed and operational app.
The development version of your app can be password protected, and we strongly recommend doing this.
Purpose
This issue is flagged to inform you that the development version of your app is not password protected, allowing anyone with the URL to access it.
Trigger
This issue will be triggered if:
You are on a paid plan.
The version-test version of your app is not password protected.
Solution
We strongly recommend password-protecting your development version, so that no one can access it without authenticating.
Solution
Navigate to Settings – General.
Locate Limit access to this app in run mode with a username and password under Privacy & Security, and check the box.
Provide a username and password different from the default
usernameandpassword.
Unauthorized collaborator access
Overview
Bubble allows you to add collaborators (see Key terms) to your app, enabling efficient teamwork and problem-solving during development. However, retaining collaborators indefinitely can pose a security risk.
Bubble's security dashboard (see Key terms) helps reduce this risk by informing you of unauthorized collaborators and asking you to ignore the notice or remove them from your app. This helps you stay in control of who has access to your app over time.
Purpose
The purpose of flagging this issue is to identify non-approved collaborators that still have access to your app.
Trigger
This issue will be triggered if:
One or more collaborators that have not been approved in the security dashboard have access to your app.
Solution
There are two ways to fix this issue:
Solution 1: Ignore the issue
Open the security dashboard.
Find the Unauthorized collaborator access issue.
Click the three dots and select Ignore forever.
Keep in mind that once ignored, Bubble will no longer flag this issue for that user. It's important to only ignore this notice for collaborators you trust and intend to keep involved with your app long-term.
Solution 2: Remove the collaborator(s)
If there's no reason for the collaborator to have access to your app anymore, you can remove them.
In Bubble, navigate to Settings – Collaboration.
Locate the collaborator(s) you want to remove.
Click remove on the right-hand side of the collaborator row.
Unsafe API call configuration
Overview
How you set up authentication in the API Connector (see Key terms) is important for keeping your external API calls secure. When a collection uses certain authentication methods and stores private values, those values are exposed.
If the authentication method is set to None or self-handled or OAuth2 User-Agent Flow, anyone can retrieve the collection’s private keys, secrets, and tokens, including users who aren’t logged in. This includes values stored in headers, query strings, and body fields, even ones marked Private. This applies whether the call is used as Data or as an Action.
Purpose
This issue is flagged to identify API Connector configurations where stored credentials are exposed to anyone who looks for them. Someone who has these credentials can use them outside your app. They can read or change data in the connected service, act as your app, or run up charges on your account. The goal is stronger control over access through secure authentication methods.
Trigger
This issue will be triggered if:
The authentication method is one of the following:
None or self-handled
OAuth2 User-Agent Flow
and
The collection contains at least one private header or parameter, on a call with Use as set to Data or Action.
Solution
To protect your API authentication setup, follow these recommendations:
Use private key in header authentication
Switch the collection to the Private key in header method. If the API authenticates another way, add a placeholder header so the collection can use this method. This means:
The key is stored securely and only sent from the server
Bubble controls who can run the call
Sensitive information isn’t exposed on the client side
Rotate your keys
Switching the authentication method doesn’t make old keys safe again. If this issue was flagged, assume the keys in the collection have already been seen. Generate new keys with each provider, revoke the old ones, and update the API Connector.
Keep secrets out of unauthenticated collections
If a collection must stay on None or self-handled, don’t store any private values in it. Move calls that need credentials into a separate collection that uses Private key in header.
Unsafe Google Maps API token
Overview
To integrate Google Maps into your Bubble app, you’ll need to input a Google Maps API key into the Bubble editor. Keep in mind that this API key is publicly accessible, which means it could be discovered and misused by unauthorized individuals.
Purpose
The purpose of flagging this issue is to notify you that your Google Maps API key is not restricted to your app’s domain, which leaves it vulnerable to potential misuse by unauthorized parties.
Trigger
This issue will be triggered if:
You have a Google Maps API key that is not restricted to your app's domain.
Bubble performs this test by locating your API key and sending a request from a different server. If the request goes through, the API key is vulnerable to misuse, and the issue is flagged.
Solution
This issue is a bit different from most security dashboard issues, as it's not fixed in the Bubble editor, but in your Google Cloud Console settings.
Solution
Open Google Cloud Console.
Navigate to APIs and Services and then Credentials (direct link if you're logged in).
Click on the API key you want to restrict.
Under Set an application restriction, choose Websites.
Then, enter these four values, assuming “myapp” is your app ID and “mydomain” is your app domain.
Be sure to add each URL twice: once for the live version and once with ‘version-test’ to allow requests from your development environment as well.
Click Save.
Sensitive credentials or parameters exposed
Overview
This issue is flagged when a secret key or sensitive parameter is accessible in a public-facing or client-side context.
Sensitive values, such as secret keys, API keys, access tokens, or API parameters containing confidential data, should not appear in page code, client-side workflows, or publicly accessible configuration fields. If exposed, they may be discovered and misused by unauthorized parties.
In some cases, integrations may continue working normally even when sensitive values are publicly accessible.
Purpose
This check helps prevent unauthorized access, service abuse, and data exposure by identifying sensitive values visible in the browser or other client-accessible locations. Exposed credentials or parameters may allow unauthorized parties to:
Access third-party services
Read or modify protected data
Abuse API usage limits
Generate unexpected charges
Compromise payment systems or integrations
Even if your app appears to work correctly, exposed sensitive values are a significant security risk. Sensitive data should only be handled in secure, server-side contexts. When stored in protected plugin (see Key terms) fields, marked as private in the API Connector (see Key terms), or used exclusively in backend workflows (see Key terms), these values are not sent to the client and can't be inspected through browser developer tools.
The exception is an API Connector collection that uses None or self-handled or OAuth2 User-Agent Flow. Values marked Private in these collections are exposed.
Article section: Unsafe API call configuration
Trigger
This issue may be triggered when Bubble detects a value resembling a secret or sensitive parameter in a client-visible location. Common scenarios include:
Secret key in a public plugin field: For example, entering a Stripe secret key into a field intended for public values (such as Client ID or Publishable Key), making it accessible in the client.
Public API Connector parameter that appears sensitive: If an API parameter is not marked as private, its value may be exposed in the browser. When such a parameter contains sensitive data, it indicates a potential security issue.
Sensitive value in client-side code: Sensitive data may be detected in locations such as:
Page source
Run mode inspector
Element properties
Client-side workflows
Data sources
Public API calls
Initialization values in API calls
Values in these locations can be extracted through browser developer tools or network inspection.
Note: This check relies on automated detection methods and may not identify all instances of exposed sensitive data. Some cases may go undetected depending on how values are structured, named, or used.
Review your app manually to confirm that no sensitive credentials or parameters are publicly accessible.
Solution
Solution 1: Rotate exposed credentials
If a secret key or credential has been exposed, generate a new one with the service provider and revoke or disable the compromised key. This is especially critical for services like Stripe.
Solution 2: Store sensitive values securely
Keep all sensitive data in protected, server-side contexts:
Use designated secret key fields in plugins.
Avoid placing secrets in public fields such as Client ID or Publishable Key.
Mark sensitive API Connector parameters as private, in a collection that uses a secure authentication method such as Private key in header.
Solution 3: Move logic to backend workflows
For dynamic credentials (for example, per user or request):
Perform API calls in backend workflows.
Make sure credentials are not initialized or referenced in the browser.
Solution 4: Remove client-side exposure
Eliminate sensitive values from:
Solution 5: Rescan your app
After applying fixes, rescan your app in the security dashboard (see Key terms) to confirm the issue has been resolved.
Unprotected backend workflow
Overview
The Bubble API (see Key terms) allows you to set up API workflows (see Key terms) that can be triggered either by your app or external clients, such as other systems or apps. However, if an API workflow is configured to run without requiring authentication, it can be executed by anyone who knows the endpoint. This can create a potential security vulnerability, as unauthorized entities could exploit it to interact with your app.
Purpose
The purpose of flagging this issue is to notify you that one or more of your API workflows have the This workflow can be run without authentication option enabled. This setting allows anyone with the endpoint URL to execute the workflow, potentially exposing your app to unauthorized access.
Trigger
This issue will be triggered if:
One or more of your API workflows have the This workflow can be run without authentication option enabled.
Solution
There are two ways to solve this issue:
Solution 1: Enable authentication on the workflow
If the workflow doesn't need to be executable without authentication, you can disable this option.
Navigate to the backend workflow editor.
Locate the API workflow.
Uncheck This workflow can be run without authentication.
Note that some requests, such as webhooks, may still need to be able to access the workflow. If so, use the method below.
Solution 2: Set up a private Bubble API key
If a client needs to access the workflow but can't log in as a regular user (such as for webhooks), consider securing the workflow by requiring a Bubble API key. This adds an additional layer of security while allowing external systems to interact with your app.
Navigate to Settings – API. You will see a button called "Create a new API Token".
Click it and give the API key a descriptive name (such as the name of the webhook client, for example "Stripe").
You will now see your private key generated randomly by Bubble.
Add this key to the endpoint that the webhook needs to access, such as:
https://yourappid.bubbleapps.io/version-live/api/1.1/wf/your-endpoint?api_token=XXX(where XXX represents the code you just generated)
Uncheck This workflow can be run without authentication.
Weak password policies
Overview
Bubble allows you to set a password policy in your app that requires all users to use a password that:
Has a minimum length (specified as a number of characters)
Includes at least one number
Includes at least one capital letter
Includes at least one non-alphanumeric character
These four options can be configured independently, allowing you to require any combination of them, from just one to all. Not enabling this feature allows users to set weak passwords, such as common dictionary words or names, which can be guessed or brute-forced by malicious actors.
Purpose
The purpose of flagging this issue is to make you aware that your app doesn't have a password policy set.
Trigger
This issue will be triggered if:
None of the password policy options in your app's settings have been set.
Note that it will only trigger when all options are empty. In other words, it can still be worth looking over your password policy even if Bubble is not flagging the issue.
Solution
We recommend implementing a password policy for all apps that handle sensitive information, as users often choose short, easily guessed passwords, such as common dictionary words or names.
Solution
Navigate to Settings – General.
Scroll to Define a password policy under Privacy & Security.
Set a password policy.
We recommend setting a password policy that requires a minimum of eight characters, including at least one number, one uppercase letter, and one special character.
Key terms
Issue explorer: The issue explorer is the part of the security dashboard that lists the issues found in your app.
Article: Issue explorer
Security dashboard: The security dashboard scans your app for common security issues and lists what it finds, along with steps to fix them.
Article: Security dashboard
Privacy rule: Privacy rules are conditions you set up on a data type to control who can find, view, and change its data.
Article: Protecting data with privacy rules
Repeating groups: A repeating group displays a list of things, such as records from your database.
Article: Repeating group element (web)
Search tool: The search tool helps you find elements, workflows, and expressions across your app.
Article: The search tool
Backend workflows: Backend workflows run on Bubble's server instead of on the user's device.
Article: The frontend and backend
Database triggers: A database trigger event runs a workflow when specific data in your database changes.
Article: Database trigger events
Data type: A data type defines a kind of record in your database, such as a user or a product, and the fields it contains.
Article: Data types and fields
Dynamic expression: A dynamic expression is a formula that Bubble evaluates when your app runs, such as Current user's email.
Article: Dynamic expressions
Privacy rules checker: The privacy rules checker is a security test that helps you see whether your privacy rules expose data.
Article: Privacy rules checker
Data API: The Data API lets external systems search for, read, create, edit, and delete records in your database.
Article: The Data API
Development version: The development version of your app, also called version-test, is where you build and test changes before they go live.
Article: Version control
Collaborator: Collaborators are other Bubble users you invite to work on your app.
Article: Collaborators
File uploader element: The file uploader element lets users upload files to your app.
Article: File upload input elements
Element property editor: The element property editor is the panel where you set the properties of the selected element.
Article: The property editor
Picture uploader element: The picture uploader element lets users upload images to your app.
Article: File upload input elements
Branch: A branch is a separate version of your app where you can work on changes without affecting other versions.
Article: Version control
Event: An event is the trigger that starts a workflow, such as a page loading or a user logging out.
Article: Frontend events
Go to page: The Go to page action sends the user to another page in your app.
Article: Navigation
Not directly tied to the current user: Because current user data loads with the page, conditions using Current user’s [field] trigger a server-side (302) redirect. Adding deeper conditions like Current user’s company’s name requires extra queries, causing a client-side redirect and potentially exposing some page data.
Log the user in: The Log the user in action lets your users log in to your app using their email and a password as credentials.
Core reference: Log the user in
Article series: User accounts
Text input elements: The input element is a single-line text field where users can enter text, which can then be used dynamically in your app. For login forms, input elements are commonly used to collect user credentials, such as email and password.
Core reference: The input element
API Connector: The API Connector is where you connect your app to external APIs, so you can use them as a data source or to trigger actions.
Article: The API Connector
Bubble API: The Bubble API lets external systems read and change your app's data and run its workflows.
Article: The Bubble API
Workflow API: The Workflow API lets external systems run workflows in your app.
Article: The Workflow API
Assign a temp password to a user: The Assign a temp password to a user action allows you to generate a new password for a user, enabling them to log in to their account and update it with a personal, unique password.
Core reference: Assign a temp password to a user
API workflow: An API workflow is a backend workflow that can be scheduled by your app or triggered by an external system.
Article: API workflows
Plugin: Plugins add new features to your app, such as elements, actions, and connections to external services.
Article: Plugins
Option sets: An option set is a static list of options stored in a database-like structure. Option sets are included in your app's code.
Article: Option sets
Custom states: A custom state stores a temporary value on an element or a page. Custom states run on the user's device.
Article: Custom states





