Oracle Database

Log into your Oracle Database via SQL Developer Web (Autonomous DB) or SQL Developer desktop. Connect to the schema you want to expose to Bubble. Run the ORDS REST-enablement commands for your schema and the specific tables. For Autonomous Database, these commands run in Database Actions (SQL worksheet). For self-managed Oracle with ORDS installed, run them in a connected SQL session. REST-enabling a schema creates the URL namespace (`/ords/{schema}/`). REST-enabling a table auto-generates four endpoints: GET (list all rows with pagination), GET by ID, POST (insert), and PUT/PATCH by ID (update). You can also REST-enable Oracle database views — this is the recommended approach for complex queries: create an Oracle view that pre-joins multiple tables and REST-enable the view as a single GET endpoint. Bubble calls one endpoint and receives the complete joined data without the complexity of multiple calls.

1-- REST-enable the schema (run as ADMIN or schema owner with ORDS_ADMIN privileges)
2BEGIN
3  ORDS.ENABLE_SCHEMA(
4    p_enabled             => TRUE,
5    p_schema              => 'HR',
6    p_url_mapping_type    => 'BASE_PATH',
7    p_url_mapping_pattern => 'hr',
8    p_auto_rest_auth      => FALSE
9  );
10  COMMIT;
11END;
12/
13
14-- REST-enable a specific table
15BEGIN
16  ORDS.ENABLE_OBJECT(
17    p_enabled        => TRUE,
18    p_schema         => 'HR',
19    p_object         => 'EMPLOYEES',
20    p_object_type    => 'TABLE',
21    p_object_alias   => 'employees',
22    p_auto_rest_auth => FALSE
23  );
24  COMMIT;
25END;
26/

For production Bubble integrations, OAuth2 Client Credentials is more secure than Basic Auth — it issues short-lived Bearer tokens rather than sending a username/password on every request. In Oracle Database Actions (or via SQL), create an OAuth2 client for Bubble. This generates a `client_id` and `client_secret`. To get a Bearer token, exchange these credentials at the ORDS token endpoint (`/ords/{schema}/oauth/token`) using Basic Auth with client_id:client_secret. The token response includes an `access_token` (Bearer token) valid for a defined duration. Alternatively, use ORDS First Party Auth (Basic Auth) with an Oracle schema-level user — simpler but sends credentials on every request. For Basic Auth: base64-encode `username:password` and use `Authorization: Basic <encoded>` as the header value. Both approaches work with Bubble's Private header. For teams with existing Oracle DBAs, OAuth2 is the recommended enterprise approach. For small teams evaluating the integration, Basic Auth is faster to set up.

1-- Create an OAuth2 Client in ORDS (run in schema that owns the REST endpoints)
2BEGIN
3  OAUTH.CREATE_CLIENT(
4    p_name            => 'bubble-app',
5    p_grant_type      => 'client_credentials',
6    p_description     => 'Bubble web app integration',
7    p_privilege_names => NULL
8  );
9  COMMIT;
10END;
11/
12
13-- Retrieve client_id and client_secret
14SELECT NAME, CLIENT_ID, CLIENT_SECRET FROM USER_ORDS_CLIENTS;
15
16-- Token endpoint (POST from Bubble API Connector to get Bearer token)
17-- POST https://{ords-host}/ords/{schema}/oauth/token
18-- Header: Authorization: Basic base64(client_id:client_secret)
19-- Body: grant_type=client_credentials

In your Bubble editor, go to the Plugins tab. If 'API Connector' by Bubble is not installed, click 'Add plugins', search 'API Connector', and install it. Click 'API Connector', then 'Add another API'. Name it 'Oracle ORDS'. In the 'Root URL' field, enter your ORDS base URL including the schema path: `https://{your-ords-host}/ords/hr` (no trailing slash). In 'Shared headers', click 'Add a shared header'. For Basic Auth: Key `Authorization`, Value `Basic ` followed by the base64-encoded `username:password` string. For OAuth2: Key `Authorization`, Value `Bearer ` followed by your access token (you will need to refresh this; see the tip below). Check the 'Private' checkbox for the Authorization header — mandatory. This ensures Bubble processes the header server-side and never sends raw Oracle credentials to any browser. Add a second shared header: Key `Content-Type`, Value `application/json` (not private). If your ORDS instance requires a specific Accept header, add `Accept: application/json` as well.

1{
2  "root_url": "https://{your-ords-host}/ords/hr",
3  "shared_headers": [
4    {
5      "key": "Authorization",
6      "value": "Basic <base64-encoded-username:password>",
7      "private": true
8    },
9    {
10      "key": "Content-Type",
11      "value": "application/json",
12      "private": false
13    }
14  ]
15}

Inside the 'Oracle ORDS' API group, click 'Add another call'. Name it 'GetEmployees' (or the appropriate table name). Set method to GET. Set endpoint to `/employees/` (the REST-enabled table alias). ORDS supports two useful query parameters: `limit` (number of rows per page, default 25) and `offset` (starting row for pagination). Add these as query parameters in the call with default values `25` and `0`. ORDS also supports `?q=` for JSON Query-by-Example filtering: add an optional `q` parameter with a default empty value `{}` — Bubble passes Oracle Query-by-Example JSON to filter rows (e.g., `{"DEPARTMENT_ID":90}` returns only department 90 employees). Click 'Initialize the call'. Bubble fetches your Oracle data via ORDS. The response follows the ORDS envelope format: `{"items":[...], "hasMore":true, "limit":25, "offset":0, "count":25}`. In the 'Use as Data' dialog, Bubble may detect the outer wrapper object as the data type. You need to configure Bubble to use the inner `items` array as the list type — set the response as a List of the row type by mapping `items[*]` in the response configuration. Name this data type after your Oracle table (e.g., 'OracleEmployee').

1// ORDS GET endpoint — table query with pagination and filter
2GET /employees/?limit=25&offset=0&q={}
3
4// ORDS response envelope format
5{
6  "items": [
7    {
8      "EMPLOYEE_ID": 100,
9      "FIRST_NAME": "Steven",
10      "LAST_NAME": "King",
11      "EMAIL": "SKING",
12      "DEPARTMENT_ID": 90,
13      "SALARY": 24000
14    }
15  ],
16  "hasMore": true,
17  "limit": 25,
18  "offset": 0,
19  "count": 25,
20  "links": [
21    { "rel": "self", "href": "https://{ords-host}/ords/hr/employees/" },
22    { "rel": "next", "href": "https://{ords-host}/ords/hr/employees/?offset=25" }
23  ]
24}

For inserting data, add a call named 'InsertEmployee'. Set method to POST, endpoint to `/employees/`. The request body is a JSON object with your Oracle table column names as keys (ORDS uses Oracle column names, uppercase). Initialize with a test payload and confirm a new row appears in your Oracle table. Set 'Use as' to 'Action'. For updating, add 'UpdateEmployee'. Set method to PUT, endpoint to `/employees/{{EMPLOYEE_ID}}` — ORDS auto-generates PUT endpoints that update a row by its primary key. The path parameter is the Oracle primary key value. Body contains only the fields to update. Set 'Use as' to 'Action'. For PL/SQL procedures exposed as ORDS REST handlers: in Oracle, create a REST handler module for your procedure (`ORDS.DEFINE_MODULE`, `ORDS.DEFINE_TEMPLATE`, `ORDS.DEFINE_HANDLER`). The procedure's IN parameters become JSON body fields in the POST call; OUT parameters return in the JSON response. Add a 'CallProcedure' call in Bubble: POST to the procedure handler endpoint, body matches the IN parameter names. This is one of the most powerful patterns — years of Oracle business logic becomes callable from a Bubble button click without rewriting any PL/SQL.

1// InsertEmployee — POST body (Oracle column names, uppercase)
2{
3  "FIRST_NAME": "{{firstName}}",
4  "LAST_NAME": "{{lastName}}",
5  "EMAIL": "{{email}}",
6  "DEPARTMENT_ID": "{{departmentId}}",
7  "HIRE_DATE": "{{hireDate}}",
8  "JOB_ID": "{{jobId}}"
9}
10
11// UpdateEmployee — PUT endpoint
12// PUT /employees/{{EMPLOYEE_ID}}
13{
14  "SALARY": "{{newSalary}}",
15  "DEPARTMENT_ID": "{{newDepartment}}"
16}
17
18// PL/SQL procedure ORDS handler registration
19BEGIN
20  ORDS.DEFINE_MODULE(
21    p_module_name    => 'hr_procedures',
22    p_base_path      => '/procedures/'
23  );
24  ORDS.DEFINE_TEMPLATE(
25    p_module_name    => 'hr_procedures',
26    p_pattern        => 'approve_expense'
27  );
28  ORDS.DEFINE_HANDLER(
29    p_module_name    => 'hr_procedures',
30    p_pattern        => 'approve_expense',
31    p_method         => 'POST',
32    p_source_type    => ORDS.SOURCE_TYPE_PLSQL,
33    p_source         => '
34      DECLARE
35        v_result VARCHAR2(100);
36      BEGIN
37        approve_expense_pkg.process(
38          p_expense_id => :expense_id,
39          p_approver   => :approver,
40          p_result     => v_result
41        );
42        :result := v_result;
43      END;'
44  );
45  COMMIT;
46END;
47/

Add a Repeating Group to your Bubble page. Set its data source to 'Get data from external API' → GetEmployees. Pass `limit` as `25` and `offset` as `(currentPage - 1) × 25` where `currentPage` is a custom state initialized to `1`. Access the OracleEmployee fields on each cell: `current cell's OracleEmployee's FIRST_NAME`, etc. Note Oracle column names are uppercase — your Bubble field names follow this convention. Add 'Previous Page' and 'Next Page' buttons that decrement and increment `currentPage`. Disable 'Previous Page' when `currentPage = 1` and disable 'Next Page' when the ORDS response's `hasMore` field is `false`. For the insert form: create a 'Submit' button workflow that calls InsertEmployee with each form input mapped to the corresponding Oracle column parameter. After a successful insert, set `currentPage` to `1` and trigger a Repeating Group refresh. For updates: store the selected row's primary key (`EMPLOYEE_ID`) in a custom state when a user clicks an edit row button. Pass this stored ID as the `{{EMPLOYEE_ID}}` path parameter in UpdateEmployee. Set up Privacy rules under Data tab → Privacy for any Bubble data types you create from ORDS data. For RapidDev's enterprise clients, this Oracle + Bubble pattern has unlocked significant productivity gains — existing Oracle infrastructure becomes accessible to non-technical teams through a polished Bubble front-end. If you want to scope a similar project, reach out at rapidevelopers.com/contact.