Notion

Open your browser and go to notion.so/my-integrations. Click 'New integration' and give it a descriptive name like 'Bubble App Integration'. Under 'Capabilities', ensure Read content and (if you plan to write) Insert content and Update content are checked. Click Save. On the next screen you will see your Internal Integration Token — it starts with secret_ and is a long string. Click 'Show' and then copy it to a temporary location such as a notes file. This token is your API key and must be kept private; it grants access to any Notion content you explicitly connect the integration to. Do not share it or put it in any code that runs in the browser.

Navigate to the specific Notion database you want Bubble to read or write. This step is non-negotiable and is the #1 cause of confusing 404 errors: even a perfectly valid token returns 'object not found' if the integration has not been explicitly connected to the database. To connect it, open the database page in Notion, click the three-dot menu (•••) in the top-right corner of the page, scroll down to find 'Connections', click it, search for the integration name you just created, and click 'Confirm'. You should see the integration name appear in the Connections list. Repeat this step for every Notion database your Bubble app will access — the connection is per-database, not account-wide.

In Bubble, open your app and go to the Plugins tab in the left sidebar. If you have not installed it yet, click 'Add plugins', search for 'API Connector', find the one published by Bubble, and click Install. Now click the API Connector entry in your plugin list. Click 'Add another API'. Name the API group something clear like 'Notion API'. Under 'Shared headers for all calls', add the first header: key = Authorization, value = Bearer YOUR_SECRET_TOKEN (replace with your actual token, and include the word Bearer followed by a space before the token). Check the Private checkbox on this header — this ensures the token is never sent to the browser. Add a second shared header: key = Notion-Version, value = 2022-06-28. This version header is required on every Notion API call; omitting it or changing the value causes HTTP 400 errors on every request. Do NOT mark Notion-Version as Private (it is not a secret, just a required API header). The base URL field can be left empty at the group level — you will specify full URLs in each individual call.

1{
2  "shared_headers": [
3    {
4      "key": "Authorization",
5      "value": "Bearer secret_your_token_here",
6      "private": true
7    },
8    {
9      "key": "Notion-Version",
10      "value": "2022-06-28",
11      "private": false
12    }
13  ]
14}

Within the Notion API group in the API Connector, click 'Add another call'. Name this call something like 'Query Database'. Notion's database query endpoint is a POST request — this surprises many users because it feels like a read operation, but the endpoint requires POST so you can send a JSON body with filters and sort criteria. Set the Method dropdown to POST. In the URL field enter: https://api.notion.com/v1/databases/YOUR_DATABASE_ID/query — replace YOUR_DATABASE_ID with the actual ID from your Notion database URL (the string of letters and numbers after the last slash, before any question mark). Set 'Use as' to 'Data' so Bubble treats the response as a data source for Repeating Groups. In the Body section, check 'Send arbitrary data' and enter a minimal JSON body to start: {"page_size": 10}. Now click 'Initialize call'. Bubble will send a real request to Notion and parse the response schema. You must have at least one row of data in the database for the initialization to detect the field types correctly. After a successful initialization, Bubble lists the detected fields from results[0].properties — you will see fields like results[0].properties.Name.title[0].plain_text for text properties. Map these to your Bubble data structure by selecting the fields you need in the response schema editor.

1POST https://api.notion.com/v1/databases/YOUR_DATABASE_ID/query
2
3Headers (shared, already configured):
4  Authorization: Bearer secret_... [Private]
5  Notion-Version: 2022-06-28
6
7Body:
8{
9  "page_size": 10,
10  "filter": {
11    "property": "Status",
12    "select": {
13      "equals": "Published"
14    }
15  },
16  "sorts": [
17    {
18      "property": "Created",
19      "direction": "descending"
20    }
21  ]
22}

Add a Repeating Group element to your Bubble page. In the Repeating Group's property editor, set Type of content to the response type from your Notion query call (it will appear as 'Notion API — Query Database's results' in the data source dropdown). Set the Data source to 'Get data from an external API' → select your Notion Query Database call. Bubble will prompt you to fill in any dynamic parameters — for example, if you configured a filter with a dynamic value, you map a Bubble input field value to that parameter here. Inside the Repeating Group, add text elements and bind each one to a field from the current cell: for example, bind a Text element to 'Current cell's results's properties Name title 0 plain_text' to display the row name. For rich text properties, Notion returns an array of text runs — use plain_text at the first array index for most cases. For number properties, the path is properties.Price.number. Test the page in Preview mode to verify the Repeating Group populates.

To let users submit data from Bubble that creates new rows in your Notion database, add a second API call to the Notion API group. Click 'Add another call', name it 'Create Page', set Method to POST, URL to https://api.notion.com/v1/pages. Set 'Use as' to 'Action' (not Data) since this call is triggered by a workflow, not bound to a display element. In the Body, check 'Send arbitrary data' and configure the JSON structure for a new Notion page. The parent must reference the database ID, and properties must match the exact property names and types in your Notion database. For a text property named 'Name', use the title type structure shown below. For the Initialize call, provide a filled-in example body and click Initialize to confirm the call structure. Then in your Bubble workflow, add a step 'Plugins → Notion API — Create Page', map your form input values to the dynamic body parameters you defined. Note: if you want this write-back to happen completely server-side (without exposing the call in client-side JavaScript), you need a Backend Workflow — which requires a paid Bubble plan.

1POST https://api.notion.com/v1/pages
2
3Body:
4{
5  "parent": {
6    "database_id": "YOUR_DATABASE_ID"
7  },
8  "properties": {
9    "Name": {
10      "title": [
11        {
12          "text": {
13            "content": "<dynamic: form input value>"
14          }
15        }
16      ]
17    },
18    "Status": {
19      "select": {
20        "name": "New"
21      }
22    },
23    "Notes": {
24      "rich_text": [
25        {
26          "text": {
27            "content": "<dynamic: notes input value>"
28          }
29        }
30      ]
31    }
32  }
33}