Skip to main content

Issue details

A reference for every issue the Bubble security dashboard can flag, with what each issue means, what triggers it, and how to fix it.

Written by Sofia Maconi

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:

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:

  1. 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.

  2. 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 user would 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:

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 username and password.

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:

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:

To learn more about how to mark data types as safe or sensitive:

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:

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:

Publicly accessible sensitive fields

Overview

Privacy rules (see Key terms) consist of two types of rules:

  • Dynamic rules: These are the rules that you set up using dynamic expressions (see Key terms). Each rule grants access to one or more users, based on fields stored on the relevant data type (see Key terms) and/or the user.

  • 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:

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:

  1. Strict: The recommended setting, offering the highest level of security and control.

  2. Automatic: A convenience and compatibility mode intended for apps where constraint permissions haven't been explicitly set.

  3. 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

  • Go to Settings – General and find the Search privacy setting.

  • Choose the Strict option.

  • Run a new scan on the security dashboard (see Key terms).

    • Follow the instructions here for any constrainable field vulnerabilities that are flagged as a result of enabling this more secure setting.

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 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:

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 as Current user is logged in or Current 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 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.

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.

Trigger

This issue will be triggered if:

  • The Data API (see Key terms) and/or Workflow API (see Key terms) is enabled in your app.

  • 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:

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 username and password.

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

  • 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.

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:

  1. 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.

  2. 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.

  3. 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:

  • Page elements

  • Option sets (see Key terms)

  • Custom states (see Key terms)

  • Client-side expressions

  • URL or query parameters

  • API initialization values

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

Did this answer your question?