How to Integrate Lovable with Doodle

Doodle's API access is available on Business and Enterprise plans. Log in to your Doodle account and navigate to Account Settings → API or look for an 'Integrations' section in your account dashboard. Doodle's API access and key generation location may vary based on your plan and account type. If you're using Doodle's current API (v2), navigate to the developer settings in your account and create an API key. The key is a static credential you include in requests. For some Doodle plan tiers, you may need to contact Doodle support to enable API access. Doodle's API base URL is https://api.doodle.com/v2 and authentication uses the X-API-Key header or a Bearer token depending on the API version. Review the current Doodle API documentation at developer.doodle.com for the exact authentication method, as Doodle has iterated on their API over time. Note that Doodle also provides a publicly accessible URL for each poll at doodle.com/poll/{pollId} — users without Doodle accounts can participate in polls through this URL. Your Lovable app can generate these links after creating polls via the API and share them with participants who will respond through Doodle's website rather than your custom UI.

In Lovable, click the '+' button next to the Preview panel to open the Cloud tab, then navigate to Secrets. Add: - DOODLE_API_KEY: your Doodle API key Doodle's authentication is straightforward — a single API key in a request header. No OAuth token exchange or credential combination is needed. The Edge Function adds 'X-API-Key: {key}' (or 'Authorization: Bearer {key}' depending on your Doodle API version) to every Doodle API request. Verify the correct header format from Doodle's API documentation for your account's API version. Doodle has changed their authentication mechanism between API versions. The current v2 API typically uses the X-API-Key header, but confirm this from the documentation you receive when API access is enabled on your account.

Create the Edge Function that handles Doodle poll operations. The core workflow involves: creating a poll with a title, description, and proposed time options; retrieving a poll's current state and all participant responses; and determining the optimal time slot based on availability data. Doodle's poll creation endpoint accepts: title (required), description (optional), options (array of datetime strings representing the proposed meeting times), and settings (object for poll configuration like whether participants need to provide a name, whether it's hidden, etc.). The poll response structure shows each participant's availability for each time option: typically available, not_available, or if_need_be (if supported). The Edge Function can calculate the optimal slot by finding the option with the highest count of 'available' responses. The poll sharing URL format is typically: https://doodle.com/poll/{pollId} — your Edge Function should return this URL after creating a poll so users can share it with participants who will respond through Doodle's website.

1// supabase/functions/doodle-proxy/index.ts
2import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
3
4const corsHeaders = {
5  "Access-Control-Allow-Origin": "*",
6  "Access-Control-Allow-Headers": "authorization, x-client-info, apikey, content-type",
7  "Access-Control-Allow-Methods": "POST, OPTIONS",
8};
9
10serve(async (req: Request) => {
11  if (req.method === "OPTIONS") {
12    return new Response("ok", { headers: corsHeaders });
13  }
14
15  try {
16    const apiKey = Deno.env.get("DOODLE_API_KEY");
17    const headers = { "X-API-Key": apiKey || "", "Content-Type": "application/json", "Accept": "application/json" };
18
19    const { operation, ...params } = await req.json();
20    let data;
21
22    if (operation === "createPoll") {
23      const response = await fetch("https://api.doodle.com/v2/polls", {
24        method: "POST",
25        headers,
26        body: JSON.stringify({
27          title: params.title,
28          description: params.description,
29          options: params.options.map((dt: string) => ({ start: dt })),
30          settings: { open: true },
31        }),
32      });
33      const poll = await response.json();
34      data = { pollId: poll.id, pollUrl: `https://doodle.com/poll/${poll.id}`, poll };
35    } else if (operation === "getPoll") {
36      const response = await fetch(`https://api.doodle.com/v2/polls/${params.pollId}`, { headers });
37      data = await response.json();
38    } else if (operation === "getParticipants") {
39      const response = await fetch(`https://api.doodle.com/v2/polls/${params.pollId}/participants`, { headers });
40      data = await response.json();
41    } else if (operation === "findBestSlot") {
42      const [pollRes, partRes] = await Promise.all([
43        fetch(`https://api.doodle.com/v2/polls/${params.pollId}`, { headers }),
44        fetch(`https://api.doodle.com/v2/polls/${params.pollId}/participants`, { headers }),
45      ]);
46      const poll = await pollRes.json();
47      const participants = await partRes.json();
48      // Count available votes per option
49      const voteCounts = (poll.options || []).map((opt: { start: string }, idx: number) => ({
50        option: opt,
51        index: idx,
52        availableCount: (participants.participants || []).filter((p: { availability: string[] }) =>
53          p.availability?.[idx] === "available"
54        ).length,
55        totalParticipants: (participants.participants || []).length,
56      }));
57      const best = voteCounts.sort((a: { availableCount: number }, b: { availableCount: number }) => b.availableCount - a.availableCount)[0];
58      data = { bestOption: best, allOptions: voteCounts, participants: participants.participants };
59    }
60
61    return new Response(JSON.stringify(data), { status: 200, headers: { ...corsHeaders, "Content-Type": "application/json" } });
62  } catch (error) {
63    return new Response(JSON.stringify({ error: error.message }), { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } });
64  }
65});

With the Edge Function working, open Lovable chat and describe the meeting scheduling UI. For group scheduling, the most important UX decisions are: how users propose time options (a date-time picker for selecting multiple options), how participants indicate availability (inline in the app or via Doodle's public poll URL), and how the optimal time is surfaced. For proposing times, a multi-select date-time picker is the ideal UI. Users pick a date and then add time slots one by one. Each slot shows as a tag in the proposal list with an 'x' to remove it. A minimum of 3-5 options gives participants enough choices to find availability. For participant responses, you have two options: direct API integration (participants respond through your Lovable UI using the addParticipant API) or the Doodle public URL (participants click the link and respond on Doodle's website). The public URL approach requires less frontend development but takes participants out of your app. For seamless in-app experience, build the inline response UI. For displaying results, a matrix grid (participants as rows, time options as columns) with availability indicators is the standard Doodle-style display. Highlight the column with the most availability. For the 'findBestSlot' function, display the winning time prominently with a 'This time works for X of Y participants' badge.

Once the poll is created and participants have responded (either through Doodle's public URL or a custom inline UI), the final step is surfacing the optimal meeting time and enabling the organizer to confirm it. The findBestSlot operation in the Edge Function calculates which time option has the most 'available' participants. Beyond the simple maximum, you may want to implement weighted scoring: give full weight to 'available' responses, partial weight to 'if_need_be' responses (if Doodle supports this in your API tier), and zero weight to 'not_available'. This helps identify the best slot even if no time is perfect for everyone. Once the organizer selects the final time, the Lovable app should: save the confirmed meeting time to Supabase, send calendar invites to participants (using a calendar service or the confirmed meeting details as plain text), and optionally update the Doodle poll status to closed. Store participant emails from the poll response so you can send notifications without requiring participants to re-enter their contact information. For enterprise group scheduling workflows with advanced routing logic, calendar system integration, or CRM-connected scheduling, RapidDev's team can help design the complete meeting orchestration layer.