Confluence

Log into Atlassian's identity management portal at `id.atlassian.com`. Click your profile avatar in the top-right corner, then select 'Manage account'. In the left sidebar, click 'Security'. Scroll down to the 'API token' section and click 'Create and manage API tokens'. Click 'Create API token', give it a descriptive label like 'Bubble Integration', and click 'Create'. Copy the token immediately — Atlassian only shows it once. If you close the dialog without copying, you will need to delete the token and create a new one. IMPORTANT: This token is different from your Atlassian account password. Using your account password instead of an API token in the Basic Auth configuration causes 401 errors on all Confluence API requests. Confluence Cloud specifically requires API tokens for programmatic access. Note your Atlassian account email address as well — you will need both the email and the API token for the Basic Auth configuration in Bubble.

In your Bubble app, open the Plugins tab and confirm the API Connector plugin is installed. Click 'Add another API' and name it 'Confluence'. SET THE AUTHENTICATION TYPE TO 'Basic Auth'. In the Username field, enter your Atlassian account email address. In the Password field, enter the API token you just generated. Tick 'Private' for the password field — Bubble will Base64-encode the email:token pair automatically. Set the base URL to: `https://YOUR_SUBDOMAIN.atlassian.net/wiki/rest/api` Replace YOUR_SUBDOMAIN with your Atlassian Cloud subdomain (e.g., if your Confluence is at acme.atlassian.net, use `https://acme.atlassian.net/wiki/rest/api`). CRITICAL: The `/wiki/rest/api` path segment is mandatory. Jira uses `/rest/api` on the same domain, but Confluence is served under `/wiki`. Every single Confluence API call will return 404 if you omit `/wiki` from the base URL. This is the number one setup mistake for this integration. Add a shared header: Content-Type: application/json.

1{
2  "api_name": "Confluence",
3  "base_url": "https://YOUR_SUBDOMAIN.atlassian.net/wiki/rest/api",
4  "auth_type": "Basic Auth",
5  "username": "your-email@example.com",
6  "password": "<private API token>",
7  "headers": [
8    {
9      "key": "Content-Type",
10      "value": "application/json",
11      "private": false
12    }
13  ]
14}

Inside the Confluence API group, click 'Add another call'. Name it 'Search Pages'. Set the method to GET and the path to `/content/search`. Add query parameters by clicking 'Add parameter': - cql (text, dynamic — this is your CQL query string) - limit (number, default 25) - expand (text, default: space,version) - start (number, default 0, for pagination) Before initializing, you need to understand CQL (Confluence Query Language). CQL is a structured query language specific to Confluence. Key operators: - `type = 'page'` — search only pages (not blog posts or attachments) - `text ~ 'keyword'` — full-text search containing 'keyword' - `space.key = 'ENG'` — filter to a specific space - `AND` — combine conditions For initialization, enter a real CQL query as the default cql value: `type='page' AND space.key='YOUR_SPACE_KEY'` (replace YOUR_SPACE_KEY with an actual space key from your Confluence). Click 'Initialize call'. Bubble sends the real request and detects response fields including results (array with id, title, type, status), _links, size, and start. Set 'Use as' to 'Data' and tick 'List'. Note the nested structure: results is the array of pages, and each result has a _links.webui field containing the Confluence page URL.

1GET https://YOUR_SUBDOMAIN.atlassian.net/wiki/rest/api/content/search
2  ?cql=type%3D'page'%20AND%20text~'<searchTerm>'
3  &limit=25
4  &expand=space,version
5Authorization: Basic <base64-encoded-email:token>

Confluence's search endpoint returns page metadata (title, ID, links) but not the actual page body content. To display content, you need a separate call to the content endpoint with the body expanded. Add another call: 'Get Page Content'. Method: GET. Path: `/content/{pageId}`. Add a dynamic path parameter pageId (text). Add a query parameter: expand (text, default: body.view). The `body.view` expand returns the page content as rendered HTML. This is important — Confluence does not return plain text. The content appears in the `body.view.value` field as a string of HTML markup. Initialize the call using a real page ID from your Confluence. Click on any page in Confluence and look at the URL: the number after `/pages/` is the page ID. Use this for initialization. In your Bubble app, when a user clicks a search result in the repeating group, trigger a workflow: call 'Get Page Content' with the selected result's ID. Store the body.view.value field in a Bubble custom state (type: text). To display the HTML content in Bubble, add an HTML element to your page (from the Elements panel, search 'HTML' — it is listed as 'HTML' element type). Set its content to the custom state containing the page body. The HTML element renders formatted HTML properly — headings, bold text, tables, and lists all display correctly. A standard Bubble text element would show raw HTML tags.

1GET https://YOUR_SUBDOMAIN.atlassian.net/wiki/rest/api/content/{pageId}?expand=body.view
2Authorization: Basic <base64-encoded-email:token>
3
4// Response structure (relevant fields):
5// {
6//   "id": "12345",
7//   "title": "Page Title",
8//   "body": {
9//     "view": {
10//       "value": "<p>HTML content here</p>",
11//       "representation": "view"
12//     }
13//   },
14//   "_links": {
15//     "webui": "/spaces/ENG/pages/12345/Page+Title"
16//   }
17// }

First, add a call to fetch available Confluence spaces so users can filter results. Add call 'Get Spaces': GET `/space`, with query params limit (25), type (global). Initialize this call — it returns a results array of spaces with key, name, and type fields. On your Bubble page, add: 1. A Dropdown element for space selection. Set choices to 'Get data from an external API → Confluence - Get Spaces'. Display field: current option's name. Value field: current option's key. 2. A Text Input element for the search term. 3. A Search button (or set the workflow to trigger on input change with a 500ms debounce via Bubble's 'run only when' condition). 4. A Repeating Group for results. The repeating group data source: 'Get data from an external API → Confluence - Search Pages'. Pass the CQL parameter as a dynamic value: `type='page' AND text~'` + Search Input's value + `' AND space.key='` + Space Dropdown's value + `'` If the dropdown has 'All Spaces' as a default, use a Bubble conditional to remove the space filter from the CQL when 'All Spaces' is selected. Inside the repeating group cell, add: - Text: current cell's result's title (make it bold) - Text: current cell's result's space's name - Text: current cell's result's version's by's displayName (author name) - A button: 'Open in Confluence' linking to the Atlassian base URL + current cell's result's _links's webui field - A button: 'Preview' that triggers the Get Page Content workflow RapidDev's team has built internal knowledge portals for multiple Bubble clients using exactly this Confluence integration pattern — if you need a multi-space portal with access controls, book a free scoping call at rapidevelopers.com/contact.

1// CQL query construction for Bubble dynamic expression:
2// type='page' AND text~'{searchInput.value}' AND space.key='{spaceDropdown.value}'
3
4// With no space filter (All Spaces selected):
5// type='page' AND text~'{searchInput.value}'
6
7// With parent page constraint:
8// type='page' AND ancestor='{parentPageId}' AND text~'{searchInput.value}'

Confluence returns paginated results using `start` (offset) and `limit` query parameters. Each response includes a `_links.next` field if more pages exist. For Bubble, implement pagination using a 'Load more' button pattern. Add a number custom state to your page: name it 'current_page_start', default 0. When the user clicks 'Load more', run a workflow: 1. Add step: Set state 'current_page_start' = current_page_start + 25 (your page size) 2. The repeating group re-fetches with the updated start value For the Confluence Free plan (10 users, 2 GB storage): API access works fully on the free plan. The 10-user limit refers to Confluence editors and viewers, not to API requests. A Bubble app reading Confluence via API counts as a single API connection, not as 10 individual users accessing Confluence. One practical limitation: if your Confluence space has pages created by more than 10 users (impossible on the free plan), you may see author information in API responses that references accounts you cannot administer. This is not an issue for the reading/searching use case described here. For client projects, note that a Confluence Cloud Standard plan ($5.75/user/month) may be required if the client already has more than 10 Confluence users. The API integration itself works the same regardless of plan.

1// Pagination pattern for Confluence content search
2GET /wiki/rest/api/content/search
3  ?cql=type='page' AND text~'query'
4  &limit=25
5  &start=<current_page_start_state>
6
7// Response includes:
8// {
9//   "results": [...],
10//   "start": 0,
11//   "limit": 25,
12//   "size": 25,
13//   "_links": {
14//     "next": "/rest/api/content/search?...&start=25"
15//   }
16// }
17// If _links.next is empty, you are on the last page