# How to Integrate Bolt.new with Practo

- Tool: Bolt.new
- Difficulty: Intermediate
- Time required: 40 minutes
- Last updated: April 2026

## TL;DR

Practo has no official public API. Their platform is a closed consumer product, and no developer API program exists for building third-party apps. Build healthcare appointment booking in Bolt.new using alternative approaches: embed Practo's booking widget if available for your clinic, or build a custom doctor appointment system with Supabase for profiles and bookings, Calendly for scheduling, or Acuity Scheduling for healthcare-specific appointment management.

## Build Healthcare Appointment Booking in Bolt.new Without Practo's API

Practo is the dominant healthcare discovery and booking platform in India with over 100 million patients and 350,000+ healthcare professionals, but the company operates as a closed consumer platform. There is no official Practo API, no developer documentation, no partner program for third-party integrations, and no announced plans to create one. Any unofficial access attempts would violate their Terms of Service. This is a well-known limitation — developers searching for a Practo API consistently find the answer is 'it doesn't exist.'

The practical alternative for building healthcare appointment functionality in Bolt.new is to either use Practo's clinic widget (if your clinic is registered on Practo and offers it), or build a custom booking system using the tools that your underlying use case actually requires. For appointment scheduling with real-time availability, Calendly (consumer-friendly, easy OAuth integration) and Acuity Scheduling (healthcare-specific features including intake forms and HIPAA considerations) both offer robust APIs. For doctor profiles, ratings, and medical records, Supabase provides an HTTP-based PostgreSQL database that works natively in Bolt's WebContainer.

The custom approach often produces a better product than a Practo integration would: you control the UX entirely, you own the patient data relationships, and you can tailor the booking flow to your specific medical specialty. The guide below builds a complete doctor directory, appointment booking, and review system that replicates the core value proposition of a Practo-style feature set.

## Before you start

- A Supabase project for storing doctor profiles, appointment data, and patient records
- A Calendly account and API key (for scheduling) OR an Acuity Scheduling account (for healthcare-specific booking)
- A SendGrid account and API key for sending appointment confirmation emails
- A Bolt.new project with Supabase connected via the database icon in the sidebar
- Understanding that Practo has no public API — this guide builds a custom equivalent

## Step-by-step guide

### 1. Set Up the Doctor and Appointment Database in Supabase

The foundation of a healthcare booking system is a well-designed database. In Bolt.new with Supabase connected, prompt the AI to create the data model. You need at minimum: a `doctors` table (id, name, specialty, qualification, clinic_name, clinic_address, consultation_fee, bio, photo_url, languages, years_experience, rating_avg, review_count); an `available_slots` table (id, doctor_id, slot_date, slot_time, duration_minutes, is_booked, appointment_id); an `appointments` table (id, patient_id, doctor_id, slot_id, reason, status, notes, created_at); and a `reviews` table (id, appointment_id, patient_id, doctor_id, rating, review_text, is_verified, created_at). Set up Row Level Security so patients can only read their own appointments, doctors can see their own schedule, and anyone can read doctor profiles and reviews. The reviews table uses the appointment_id foreign key to enforce that only patients who had a real appointment can leave a verified review — this is the key trust mechanism.

**Expected result:** Supabase has all required tables with proper foreign keys, RLS policies, and sample doctor data. The Bolt preview can read doctor profiles from the database.

### 2. Build the Doctor Directory and Search UI

Create the patient-facing doctor listing page. This is the most-visited page in any healthcare booking app — users need to quickly filter by specialty, location, language, and availability. Build a DoctorCard component that shows: doctor photo, name, qualification, specialty, clinic name, consultation fee, rating with star display, and a 'Book Appointment' button. Add filter controls at the top: specialty dropdown (Cardiologist, Dermatologist, General Physician, Gynecologist, Orthopedic, Pediatrician, Psychiatrist, etc.), available today checkbox, and maximum fee slider. Sort options: Most Reviewed, Highest Rated, Lowest Fee. Data comes from Supabase via the `@supabase/supabase-js` client, which uses HTTP (PostgREST) — fully compatible with Bolt's WebContainer. The doctor listing page can be fully built and tested in Bolt's preview before connecting real scheduling logic.

**Expected result:** The doctor directory page shows a filterable, sortable grid of doctor cards fetched from Supabase, working in Bolt's WebContainer preview.

### 3. Integrate Calendly for Real-Time Scheduling

Calendly provides the scheduling backbone — real-time availability, buffer times between appointments, timezone handling, and booking confirmation. Each doctor gets a Calendly event type (e.g., '30-minute consultation') linked to their Bolt profile. For the simplest integration, embed Calendly's scheduling widget using their `inline_embed` or `popup_widget` JavaScript — this requires no API calls and works in the WebContainer. For a more integrated experience, use the Calendly v2 API (OAuth 2.0 or personal access token) to fetch the doctor's scheduled events, check availability, and trigger booking creation from your custom UI. The API endpoint `/event_type_available_times` returns available slots for a given event type URL and date range. When a booking is completed, Calendly fires a webhook to your app — this requires a deployed URL. Store the Calendly event URI in your `appointments` table alongside your own appointment record so you can look up or cancel through Calendly's API if needed.

```
// app/api/appointments/create/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
);

export async function POST(request: NextRequest) {
  const { doctorId, patientId, slotId, reason, calendlyEventUri } = await request.json();

  // Mark the slot as booked
  const { error: slotError } = await supabase
    .from('available_slots')
    .update({ is_booked: true })
    .eq('id', slotId);

  if (slotError) return NextResponse.json({ error: slotError.message }, { status: 400 });

  // Create the appointment record
  const { data, error } = await supabase
    .from('appointments')
    .insert({
      patient_id: patientId,
      doctor_id: doctorId,
      slot_id: slotId,
      reason,
      status: 'scheduled',
      notes: calendlyEventUri ? `Calendly: ${calendlyEventUri}` : null,
    })
    .select()
    .single();

  if (error) return NextResponse.json({ error: error.message }, { status: 400 });
  return NextResponse.json({ appointment: data });
}
```

**Expected result:** Patients can book appointments through an embedded Calendly widget, and booking details are stored in Supabase.

### 4. Build the Doctor Review and Rating System

Reviews are a critical trust signal in healthcare apps — patients rely on them heavily before booking. Build a review system where only verified patients (those with a completed appointment) can leave reviews, displaying a badge to distinguish verified reviews from unverified ones. The reviews table uses the appointment_id as a foreign key — this database constraint ensures that a review can only be submitted by someone who had a real appointment with that doctor. After a patient's appointment status changes to 'completed', show a 'Leave a Review' prompt in their appointment history. The review form should include: star rating (1-5), required written feedback (minimum 50 characters), and an optional 'Would Recommend' checkbox. After submission, update the doctor's `rating_avg` and `review_count` fields via a Supabase database function or trigger for consistent aggregation. Display reviews on the doctor profile page sorted by most recent, with verified badge, date, and helpful vote count.

**Expected result:** Patients with completed appointments can leave verified reviews. Doctor profiles show aggregate ratings and the review list with verified patient badges.

## Best practices

- Be transparent with users that your app is not affiliated with Practo — build trust by clearly branding your own platform
- Use verified review badges (tied to actual appointment records via foreign key) to distinguish genuine patient reviews from unverified ones
- Store each doctor's Calendly or Acuity scheduling URL in your database so the booking flow works per-doctor without hardcoding
- Add Row Level Security to appointment and patient data so patients can only see their own records and doctors can only see their own schedule
- For HIPAA compliance considerations, review your database and hosting setup if serving US healthcare — Indian healthcare apps have separate compliance requirements under DPDP Act 2023
- Test appointment booking flows on your deployed URL rather than Bolt's preview — Calendly webhooks require a publicly accessible endpoint
- Implement appointment reminder notifications (email or SMS via SendGrid or Twilio) to reduce no-shows

## Use cases

### Doctor Directory with Appointment Booking

A clinic or hospital builds a patient-facing portal where patients can browse doctor profiles by specialty, check availability, and book appointments. Patient records and appointment history are stored in Supabase.

Prompt example:

```
Build a doctor booking portal. Create a Supabase database with tables for doctors (name, specialty, clinic, photo, bio, consultation_fee, languages), available_slots (doctor_id, date, time, is_booked), and appointments (patient_id, doctor_id, slot_id, reason, status, notes). Build a doctor listing page with specialty filter and a booking flow where patients select a slot and provide their reason for visit.
```

### Doctor Review and Rating System

Allow patients to leave reviews and star ratings for doctors after appointments. Show aggregate ratings, verified review badges (for patients who actually had an appointment), and sorted review listings. Useful for healthcare provider marketplaces targeting the 'review API' search query.

Prompt example:

```
Build a doctor review system. Patients who completed an appointment can leave a rating (1-5 stars) and written review. Show the doctor's average rating, total review count, and rating distribution (5-star breakdown). Mark reviews as 'Verified Patient' if the reviewer has a completed appointment record in the database. Allow sorting by most recent, highest rated, lowest rated.
```

### Teleconsultation Booking with Video

Book video consultations with doctors and send both doctor and patient a unique video call link. Use Calendly for scheduling and a video platform like Daily.co for the actual consultation room.

Prompt example:

```
Build a teleconsultation booking app. Patients select a doctor, pick an available time slot via Calendly integration, and receive a confirmation email with a video call link. Use the Calendly API to show the doctor's real-time availability. After booking, send confirmation via SendGrid with a meeting link. Store the booking in Supabase.
```

## Troubleshooting

### Cannot find any Practo API documentation or developer portal

Cause: Practo has no public API. The company does not offer a developer program, API keys, or official documentation for third-party integration.

Solution: Use the alternatives described in this guide. For appointment booking, use Calendly or Acuity Scheduling. For a custom doctor directory, use Supabase as your database backend. There is no legitimate way to access Practo's data programmatically.

### Calendly embedded widget does not display in Bolt's preview

Cause: Some browser security settings or Bolt's iframe environment can interfere with Calendly's inline embed script.

Solution: Try the Calendly popup widget instead of inline embed — it opens in a new window/overlay that bypasses iframe restrictions. Alternatively, provide a direct Calendly booking link on the doctor's profile page for users to open in a new tab during development, then test the embedded widget on your deployed URL.

### Supabase RLS policy blocks patients from reading doctor profiles

Cause: An overly restrictive RLS policy requires authentication for all reads, but doctor profiles should be publicly visible.

Solution: Add a SELECT policy on the doctors table that allows read access without authentication: CREATE POLICY "Public can view doctors" ON doctors FOR SELECT USING (true). Keep write operations (INSERT, UPDATE, DELETE) restricted to authenticated users and admin roles.

```
-- Allow public read access to doctor profiles
CREATE POLICY "Public can view doctors" ON doctors
FOR SELECT USING (true);

-- Only authenticated users can write
CREATE POLICY "Authenticated users can update doctors" ON doctors
FOR UPDATE USING (auth.uid() = id);
```

### Calendly webhook events not arriving after appointment booking

Cause: Calendly webhooks send HTTP POST requests to your registered URL. Bolt's WebContainer preview cannot receive incoming HTTP connections.

Solution: Deploy to Netlify or Bolt Cloud first, then register your deployed URL in Calendly's webhook settings (Account → Integrations → Webhooks). During development, test webhook handling by sending mock POST requests to your API route using a tool like Postman.

## Frequently asked questions

### Does Practo have a public API for building healthcare apps?

No. Practo operates as a closed consumer platform with no public API, developer documentation, or official partner program. There is no legitimate way to integrate Practo data into third-party apps. If you need healthcare appointment booking functionality, build a custom system using Calendly, Acuity Scheduling, and Supabase as described in this guide.

### Is there a Practo booking widget I can embed in my website?

Practo offers clinic widget options to some registered healthcare providers on their platform — this allows clinics to embed a Practo booking button on their own website. This is only available to clinics already listed on Practo and is a widget for their own Practo profile, not a general API for building custom booking systems. Contact Practo directly if you are a healthcare provider looking to use this option.

### How do I build a doctor appointment booking app in Bolt.new without Practo?

Create a doctor profiles database in Supabase, integrate Calendly or Acuity Scheduling for real-time availability and booking, use SendGrid for appointment confirmation emails, and build the patient-facing UI in Bolt. This gives you full control over the booking experience and patient data, often producing a better product than a Practo integration would allow.

### Can I build a review system for doctors in Bolt.new?

Yes. Create a reviews table in Supabase with a foreign key to your appointments table. This enforces that only patients who had a real appointment can submit a verified review. Build a star rating UI, aggregate rating calculations via a Supabase RPC function, and display reviews on doctor profile pages. This is covered in detail in Step 4 of this guide.

### Does Calendly work in Bolt's WebContainer preview?

Calendly's inline embed widget may have limitations in the preview iframe. Use signInWithPopup to open the Calendly scheduling page as a popup, or provide a direct link to the doctor's Calendly page during development. Test the fully embedded experience on your deployed Netlify or Bolt Cloud URL. Calendly webhooks for booking notifications also require a deployed URL.

---

Source: https://www.rapidevelopers.com/bolt-ai-integrations/practo
© RapidDev — https://www.rapidevelopers.com/bolt-ai-integrations/practo