Azure Machine Learning

Open Azure ML Studio at ml.azure.com and navigate to Endpoints in the left sidebar. Click on your deployed online endpoint, then open the Consume tab. You will see two items: the REST endpoint URL (looks like https://{endpoint-name}.{region}.inference.ml.azure.com/score) and two API keys — Primary key and Secondary key. Copy the endpoint URL and the Primary key. Keep these open in a separate tab as you'll paste them into Bubble shortly. Important note: this inference endpoint URL is completely different from the Azure management API URL (management.azure.com). The Consume tab gives you the correct URL for submitting predictions. If your endpoint URL does not end in /score, double-check that you're looking at an Online endpoint, not a Batch endpoint — batch endpoints work differently and require a separate Bubble workflow pattern. Also note the Input schema on the Consume tab — it shows the expected JSON shape your model accepts. Screenshot or copy this schema; you'll need it when building the request body in Step 4.

In your Bubble editor, click the Plugins tab in the left sidebar. Click 'Add plugins', search for 'API Connector', and install the plugin by Bubble. Once installed, click 'Add another API' to create a new API group. Name the group 'Azure ML'. In the Authentication field, leave it on 'None or self-handled' — you will add the auth header manually as a shared header below, which gives you full control over the header name and keeps the value server-side. Under Shared headers, click 'Add a shared header'. Set the key to Authorization and the value to Bearer YOUR_API_KEY — but do not type the key directly. Instead, type Bearer (with a space after it), then click the blue token icon to add a parameter. Name the parameter azure_ml_key, check the 'Private' checkbox, and set the default value to your actual API key. The Private checkbox is critical: it ensures the key is injected server-side by Bubble's infrastructure and never appears in browser network requests. Set the base URL to the first portion of your endpoint URL, up to but not including /score — for example https://my-endpoint.eastus.inference.ml.azure.com.

1{
2  "api_name": "Azure ML",
3  "base_url": "https://{endpoint-name}.{region}.inference.ml.azure.com",
4  "shared_headers": {
5    "Authorization": "Bearer <azure_ml_key: PRIVATE>"
6  }
7}

Within the Azure ML API group, click 'Add a new call'. Name it 'getPrediction'. Set the method to POST and the path to /score — this combines with your base URL to form the full inference endpoint URL. In the Body section, switch the content type to JSON/Body. You need to enter a valid prediction request body that matches your model's expected input schema. Azure ML's standard format wraps inputs in an 'input_data' object (for MLflow models) or an 'instances' array (for other formats). Check your model's Consume tab to see which format it expects. For a typical MLflow classification model the body looks like: { "input_data": { "columns": ["feature1", "feature2", "feature3"], "data": [[<value1>, <value2>, <value3>]] } } For the initialize call, you must provide a real valid input that your model will accept and return a successful response for. Click 'Initialize call'. Bubble will make a live POST to your endpoint using your Private key. If the model is running and your input is valid, you'll see a JSON response with predictions. Bubble will parse the response shape and allow you to reference fields by path in your workflows. If initialization fails with a 400 error, your input schema doesn't match the model's expected format — go back to the Consume tab in Azure ML Studio and verify the sample request body shown there. If you get a 401, double-check that the Private header value is correctly set to Bearer followed by a space and then the key.

1{
2  "method": "POST",
3  "url": "https://{endpoint-name}.{region}.inference.ml.azure.com/score",
4  "headers": {
5    "Authorization": "Bearer <private>",
6    "Content-Type": "application/json"
7  },
8  "body": {
9    "input_data": {
10      "columns": ["age", "subscription_plan", "support_tickets"],
11      "data": [[35, "pro", 2]]
12    }
13  }
14}

Now wire the API call to a user-facing form. In the Bubble editor, design a page with Input elements for each feature your model expects — for example, three Number inputs for age, plan type, and support ticket count. Add a Button element labeled 'Get Prediction'. Click the button, open the workflow editor, and add a step: 'Plugins → Azure ML - getPrediction'. In the body parameter fields that appear, map each input field to the corresponding model feature. Bubble automatically shows parameter fields for the dynamic parts of your request body. After the API call step, add another workflow step to store or display the result. To show the prediction score directly, you can use a 'Display data' action to put the API response value into a Custom State, then display that Custom State in a Text element. For more complex flows — such as saving the prediction to a database record — add a 'Make changes to a Thing' step after the API call and reference the response path. Make sure the database type has a field for the score (e.g., a Number field called 'prediction_score'). Always add a Bubble error workflow for this API call: click the 'Add an action' in the workflow, go to 'General' → 'Custom error handling'. Log the error details to a database record or display a friendly message — Azure ML endpoints can return 503 during cold starts or if the compute cluster needs to scale up.

If you need to call the Azure management API — for example to list available model versions, check deployment status, or fetch workspace metadata — you need Azure AD service principal authentication, not the endpoint API key. This step covers that more complex path. If you only need to call the inference endpoint, you can skip this step. First, in Azure Portal, go to Azure Active Directory → App registrations → New registration. Name it something like 'Bubble ML App'. After creation, note the Application (client) ID and Directory (tenant) ID from the Overview page. Then go to Certificates & secrets → New client secret, create a secret, and copy the value immediately (it won't be shown again). Next, assign this service principal the AzureML Data Scientist role: go to your Azure ML workspace in the Portal → Access control (IAM) → Add role assignment → select 'AzureML Data Scientist' → assign to your app registration. In Bubble, create a new API Connector call (you can add it to the Azure ML group) named 'getAzureToken'. Set method to POST and URL to https://login.microsoftonline.com/{your-tenant-id}/oauth2/v2.0/token. Set the body type to 'x-www-form-urlencoded' and add these parameters: grant_type=client_credentials, client_id={your_client_id}, client_secret={your_client_secret, marked Private}, scope=https://management.azure.com/.default. Initialize this call — it should return an access_token string and expires_in: 3600. Then create a Backend Workflow (requires Bubble paid plan) that runs this getAzureToken call on page load or before management API calls, stores the access_token in the current User's field 'azure_ml_token', and sets a 'azure_token_expiry' datetime field to Current date/time + 3600 seconds. Before each management API call, check if the current time exceeds the expiry and refresh if needed.

1{
2  "method": "POST",
3  "url": "https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token",
4  "headers": {
5    "Content-Type": "application/x-www-form-urlencoded"
6  },
7  "body": {
8    "grant_type": "client_credentials",
9    "client_id": "<your_client_id>",
10    "client_secret": "<private: your_client_secret>",
11    "scope": "https://management.azure.com/.default"
12  }
13}

If your Bubble app stores prediction results in the database — for example, a 'PredictionRecord' data type with score, input features, and the user who ran it — you must configure Bubble's privacy rules to control who can read and modify these records. Go to the Data tab in Bubble's editor → Privacy. Select the data type you created for storing predictions. By default, Bubble may expose all fields to any logged-in user. Add privacy rules that restrict reads to: 'Current User is the record's owner' or equivalent. This is especially important if prediction inputs contain sensitive business data. Also check that your API Connector calls don't expose the azure_ml_key through workflow logs. Go to Logs tab → check 'Log API calls' settings. In Bubble's API Connector, Private parameters are redacted in logs by default — but double-check that no raw key values appear in any workflow conditions or debug output. For production apps, periodically rotate your Azure ML endpoint API key in Azure ML Studio (Endpoints → your endpoint → Consume → Regenerate primary key) and update the Private parameter value in Bubble's API Connector settings. RapidDev's team has set up dozens of Azure ML integrations like this — if you want a free scoping call to review your architecture, visit rapidevelopers.com/contact.