Practo

Practo's API access is reserved for clinics and healthcare businesses enrolled in the Practo Ray program. To apply, contact Practo directly through their website (practo.com/ray) or your existing Practo account manager. Explain your use case — building a custom operations dashboard, kiosk check-in flow, or multi-clinic aggregation panel. Practo will provide an API key linked to your clinic's site ID. While waiting for credentials, clarify two critical constraints with your clinic's legal or data officer: (1) Patient data from Practo (names, phone numbers, appointment history, medical notes) is sensitive health information. In India it is regulated under data privacy legislation; for clinics serving international patients, additional regulations may apply. Before storing any Practo-sourced patient records in Bubble's database, ensure your data processing agreements cover this. (2) Practo's API does not have publicly documented endpoint specifications — Practo provides documentation to approved partners, but endpoints and parameters may change without public notice. Build defensively: every Bubble workflow that calls Practo must handle empty or error responses gracefully, not crash. Also note: Practo's sibling platform documentation from other integration platforms confirms the base URL is https://api.practo.com, but exact endpoint paths and parameter formats should be verified against the documentation Practo provides with your partner credentials. This guide uses patterns consistent with REST conventions and confirmed partner documentation patterns.

In your Bubble editor, click the Plugins tab in the left sidebar. Click 'Add plugins', search for 'API Connector', and install the API Connector by Bubble (free, official Bubble plugin). After installation, the API Connector appears in your Plugins tab. Click on API Connector and then click 'Add another API'. Name this API group 'Practo'. In the Authentication section, select 'None or self-handled' — you will add the API key manually as a custom header rather than using Bubble's built-in OAuth flow. Set the API base URL to https://api.practo.com. Now add a shared header that applies to all Practo calls. Click 'Add a shared header'. Set the key to Api-Key (match this exactly to what Practo's documentation specifies — it may be Api-Key, api-key, or x-api-key depending on your partner documentation). Set the value to your partner API key. CRITICAL: check the 'Private' checkbox next to this header. This tells Bubble to keep this header server-side and never include it in any data sent to the browser. The Private checkbox is the core security mechanism in Bubble's API Connector — without it, your partner key would be visible in browser network requests. If your Practo API documentation specifies a site ID or clinic ID header, add it as another shared header. If it is a URL parameter instead, you will configure it at the call level in the next step.

1{
2  "api_name": "Practo",
3  "base_url": "https://api.practo.com",
4  "authentication": "None or self-handled",
5  "shared_headers": [
6    {
7      "key": "Api-Key",
8      "value": "YOUR_PRACTO_PARTNER_API_KEY",
9      "private": true
10    },
11    {
12      "key": "Content-Type",
13      "value": "application/json",
14      "private": false
15    }
16  ]
17}

Within the Practo API group, click 'Add another call'. Name this call 'Get Appointments'. Set the method to GET and the endpoint path to the appointments endpoint from your Practo partner documentation (typically something like /v1/appointments or /appointments, with your clinic's site ID as a path segment or query parameter). Add URL parameters that Practo requires: date (today's date in the format Practo expects, e.g., YYYY-MM-DD), site_id (your clinic identifier), and optionally status (to filter by appointment status) and page/per_page (for pagination). For the date parameter, you can set a default test value for initialization and make it dynamic when used in workflows. Set 'Use as' to 'Data' — this tells Bubble this call returns a list of records you can bind to UI elements, not just trigger a side effect. Click 'Initialize call'. Bubble will make a real HTTP GET request to the Practo API using your credentials. The initialization must succeed with actual data from your clinic — Bubble records the response shape and makes each field available as a selectable property in the editor. IMPORTANT: If initialization fails with 'There was an issue setting up your call', the most common causes are: (1) incorrect API key (copy-paste error, extra whitespace), (2) the endpoint path differs from what Practo's documentation shows, or (3) required parameters are missing or in the wrong format. Check the exact error by temporarily removing the Private checkbox, running the call, and looking at the browser's network inspector — then re-check Private immediately. After successful initialization, add a second call for individual appointment details (GET /appointments/{id}), a third for patient lookup if your use case needs it, and a POST call for updating appointment status.

1{
2  "call_name": "Get Appointments",
3  "method": "GET",
4  "path": "/v1/appointments",
5  "use_as": "Data",
6  "parameters": [
7    { "key": "date", "value": "2026-07-09", "description": "Date in YYYY-MM-DD format" },
8    { "key": "site_id", "value": "YOUR_CLINIC_SITE_ID", "description": "Practo clinic site identifier" },
9    { "key": "status", "value": "scheduled", "description": "Filter: scheduled, checked-in, completed" },
10    { "key": "page", "value": "1", "description": "Page number for pagination" },
11    { "key": "per_page", "value": "50", "description": "Records per page" }
12  ]
13}
14
15{
16  "call_name": "Update Appointment Status",
17  "method": "POST",
18  "path": "/v1/appointments/<appointment_id>/status",
19  "use_as": "Action",
20  "body": {
21    "status": "<dynamic: new status>"
22  }
23}

Even when using Practo primarily as a live API data source (not storing records), you may need Bubble Data Types for operational state — tracking check-in status, adding internal notes, or caching appointment data for display. If your workflow stores any Practo-sourced patient information in Bubble, Privacy rules are mandatory. Create an Appointment Data Type with fields: practo_appointment_id (text), patient_name (text), patient_phone (text), scheduled_time (date), doctor_name (text), status (text), checked_in_at (date), clinic_staff_note (text), user (User — the clinic staff member who last interacted with this record). Create a Patient Data Type only if you are storing patient records (not just appointment references): patient_id (text), name (text), phone (text), last_appointment (date). Now go to the Data tab → Privacy tab. For Appointment: click 'Define rules for Appointment'. Add a condition: 'This Appointment is visible when Current User is logged in AND Current User has a role of clinic_staff'. Never use 'Everyone can view' for appointment or patient records. For the Patient type (if used): same restriction — clinic staff only. Click 'Find fields exposed to others' and confirm that no fields are accessible to logged-out users or users without the clinic staff role. For Bubble apps used by multiple clinic staff members, add a 'role' option field to the User Data Type (values: reception, nurse, doctor, admin) and configure Privacy rules to match appropriate access levels — receptionists see appointment queue but not consultation notes, doctors see their own patient records only, admins see all. RapidDev's team regularly builds custom clinic dashboards on top of healthcare APIs — for complex multi-role access control or PDPB compliance questions, a free scoping call is available at rapidevelopers.com/contact.

Create a new page in Bubble named 'appointment_queue'. Set a page condition: 'Only show page content when Current User is logged in AND has clinic_staff role' — redirect to a login page otherwise. This ensures patients or unauthenticated users cannot access the queue. Add a Repeating Group to the page. For the data source, click 'Do a search for' and in the Type dropdown look for the API Connector call. Select 'Get Appointments' from the Practo API group. Wire the date parameter to today's date (use the expression 'Current date/time') and the site_id to a constant or app-level configuration value. Set pagination: use Bubble's built-in pagination on the Repeating Group, or manually pass the page parameter to load records in batches. Inside each cell of the Repeating Group, add Text elements for: Current cell's appointment's scheduled_time (formatted as HH:MM AM/PM), Current cell's appointment's patient_name, Current cell's appointment's doctor_name, Current cell's appointment's status. Add a Dropdown element with options (Waiting, Checked In, In Consultation, Completed) that triggers a workflow on change: run API Connector action 'Update Appointment Status' with the current cell's appointment ID and the selected dropdown value. Add a 'Refresh' button above the Repeating Group that re-runs the API Connector Get Appointments call. For auto-refresh, use a Timer element (Bubble Toolbox plugin) set to trigger every 120 seconds and re-run the appointments search. For pagination handling of large clinic queues: add 'Load More' button below the Repeating Group that increments the page parameter and fetches the next batch. Practo's API returns paginated results — never try to fetch all records at once for clinics with large appointment volumes, as this can hit Bubble's 30-second workflow timeout and wastes API rate limit quota.

Practo's API returns paginated responses for appointment lists. A busy clinic with 80+ appointments in a day must load them in pages, typically 20–50 records per page. In your Bubble workflow, store the current page number in an App State or a Bubble Data Thing so the 'Load More' button can increment it correctly. For error handling, Bubble's API Connector will throw a workflow error if the Practo API returns a non-2xx status code. Add error handling to every workflow that calls Practo: in the Workflow editor, click the action → Add a 'When an error occurs' handler → show a custom error popup with a friendly message like 'Appointments could not be loaded — please check your connection and try again'. Specifically handle the case where Practo's API key has expired or been revoked (401 Unauthorized response): the error handler should redirect clinic staff to an admin page with instructions to contact the Practo partner account manager. An unhandled 401 that silently shows an empty appointment queue could cause a clinic to miss patient appointments. For empty state: if the Practo call returns an empty appointments list (no appointments today, or no records matching the filter), the Repeating Group will be empty. Add an 'Empty list' state element to the Repeating Group with a message like 'No appointments scheduled for today' — this distinguishes an empty response from an error response.

1// Error response handling pattern in Bubble API Connector
2// Add to each Practo-connected workflow:
3
4// Step 1: Call Practo Get Appointments
5// Add error handler: 'When Get Appointments fails'
6//   Action: Show element 'ErrorPopup'
7//   Set state: ErrorPopup's error_message = error body's message
8
9// Sample Practo error response shapes to handle:
10// 401: { "error": "Unauthorized", "message": "Invalid API key" }
11// 404: { "error": "Not Found", "message": "Site ID not found" }
12// 429: { "error": "Rate Limited", "message": "Too many requests" }
13// 500: { "error": "Server Error", "message": "Internal server error" }