Redis

Go to console.upstash.com and sign in or create a free account. Click 'Create Database' and choose a name and region closest to your users. Select the 'Global' option if your Bubble app serves users in multiple regions. Once the database is created, you land on its detail page. You need two values: the REST URL (it looks like `https://global-loved-hedgehog.upstash.io` — unique to your database) and the REST Token (a long string starting with `A...`). Copy both into a temporary text file. Keep the REST Token private — it has full read and write access to your database, including destructive commands like FLUSHALL. The Upstash free tier allows 10,000 commands per day, resetting at midnight UTC. If your Bubble app runs high traffic, monitor usage in the Upstash console and upgrade to pay-as-you-go before hitting the daily limit.

In your Bubble editor, click the Plugins tab in the left sidebar. If 'API Connector' by Bubble is not already listed, click 'Add plugins', search for 'API Connector', and install it. Now click 'API Connector' in your plugins list and then 'Add another API'. Name it 'Upstash Redis'. In the 'Root URL' field, paste your Upstash REST URL: `https://{your-db-id}.upstash.io`. Below the root URL, you see 'Shared headers'. Click 'Add a shared header'. In the Key field type `Authorization`, in the Value field type `Bearer ` followed by your Upstash REST Token (leave a space after 'Bearer'). Most importantly: check the checkbox labeled 'Private'. The Private checkbox tells Bubble to process this header on its servers and never include the raw token value in any client-side code or browser network requests. This is the correct and only safe place for the Upstash REST Token.

1{
2  "root_url": "https://{your-db-id}.upstash.io",
3  "shared_headers": [
4    {
5      "key": "Authorization",
6      "value": "Bearer <your-upstash-rest-token>",
7      "private": true
8    }
9  ]
10}

Inside the Upstash Redis API group, click 'Add another call'. Name this call 'GetKey'. Set the method to GET (Upstash REST uses GET for all commands, including reads and writes — this is intentional and correct). In the endpoint field, type `/get/{{key}}`. The `{{key}}` placeholder becomes a dynamic parameter you pass from Bubble workflows. Click the small wrench icon next to `key` to mark it as a 'Path' parameter and give it a default test value like `test_key`. Now click 'Initialize the call'. Bubble needs to make a real, successful HTTP request to detect the response shape. The call will return {"result":null} because `test_key` does not exist in your database — that is a valid response. Click 'Save' on the response shape. Set 'Use as' to 'Data' so Bubble creates a data type from the response. The detected type will have a single field: `result` (text). This is the field you read in subsequent workflow conditions.

1{
2  "method": "GET",
3  "endpoint": "/get/{{key}}",
4  "params": [
5    {
6      "key": "key",
7      "value": "test_key",
8      "type": "path",
9      "private": false
10    }
11  ]
12}

Add a second call named 'SetKey'. Set method to GET, endpoint to `/set/{{key}}/{{value}}`. Add an optional query parameter: key `ex`, value `{{ttl}}` (TTL in seconds, default `3600`). Initialize the call — it returns `{"result":"OK"}`. This confirms the value was stored. Set 'Use as' to 'Action' since SetKey is a write operation you trigger from workflows, not a data source you bind in the UI. Add a third call named 'IncrKey'. Set method to GET, endpoint to `/incr/{{key}}`. Initialize — it returns `{"result":1}` (the new counter value after incrementing). Set 'Use as' to 'Action'. Optionally, add a fourth call 'ExpireKey': GET `/expire/{{key}}/{{seconds}}` for setting TTL on existing keys (used alongside INCR for rolling rate-limit windows). All four calls use GET method — this is the defining feature of Upstash's REST API and the reason it works with Bubble where standard Redis clients do not. Never set these calls to POST — doing so returns 404 errors.

1// SetKey call
2{
3  "method": "GET",
4  "endpoint": "/set/{{key}}/{{value}}",
5  "query_params": [
6    { "key": "ex", "value": "{{ttl}}", "default": "3600" }
7  ]
8}
9
10// IncrKey call
11{
12  "method": "GET",
13  "endpoint": "/incr/{{key}}"
14}
15
16// ExpireKey call
17{
18  "method": "GET",
19  "endpoint": "/expire/{{key}}/{{seconds}}"
20}

This step shows the core Upstash caching pattern in Bubble workflows. Suppose you call a slow third-party API (e.g., a product catalog API) on page load. Open your Bubble workflow editor and create a 'Page is loaded' event workflow. Step 1: Run 'Get data from an external API' → select GetKey → set `key` to `cache_products` (or a dynamic key per user). Step 2: Add a condition branch using 'Only when' on an action: check if the GetKey result's `result` field is not empty. If it IS empty (null), proceed to Step 3. If it has a value, jump to Step 5. Step 3 (cache miss): Call your real third-party API workflow. Step 4: Run SetKey — set `key` to `cache_products`, `value` to the serialized API response, `ttl` to `3600`. Step 5 (both paths converge): Populate your Bubble data source from either the cached or fresh response. This pattern means Bubble only calls the expensive external API once per hour. Measure your Bubble WU consumption before and after enabling the cache to verify savings — the cache is most valuable when the external call is slow and runs on every page load.

Rate limiting prevents a user from submitting a form, clicking a button, or triggering an action more than N times within a rolling window. In your Bubble workflow editor, create a workflow triggered by a button click (e.g., 'Submit form'). Step 1: Run IncrKey with `key` set to `rate_limit_` + the current user's unique ID (combine 'rate_limit_' text with the Current User's Unique ID field in Bubble's expression builder). The result comes back as a number in the `result` field. Step 2: Add a conditional action that only runs 'Only when IncrKey's result = 1' — run ExpireKey with the same key and `seconds` set to `3600`. This sets the rolling 1-hour window on the first use. Step 3: Add a condition on all subsequent form steps 'Only when IncrKey's result ≤ 5' (or your chosen limit). Step 4: If the count exceeds 5, show an alert popup with an error message and stop the workflow using the 'Terminate this workflow' action. If within the limit, proceed with the form submission steps. Remember: key names must be URL-safe. Construct your key as `rate_limit_` followed by the user ID — do not include email addresses or special characters in key names.