diff --git a/scripts/process-batch-rsvp.ts b/scripts/process-batch-rsvp.ts
new file mode 100644
index 00000000..a4b4f254
--- /dev/null
+++ b/scripts/process-batch-rsvp.ts
@@ -0,0 +1,401 @@
+/**
+ * Batch RSVP processor script
+ *
+ * Processes pending batch_rsvp_jobs by:
+ *   1. Loading the Luma embed page via Playwright
+ *   2. Solving the Cloudflare Turnstile challenge
+ *   3. Extracting the token
+ *   4. Calling submitLumaRegistration with the token
+ *   5. Updating job status in Supabase
+ *
+ * Usage:
+ *   npx tsx scripts/process-batch-rsvp.ts [options]
+ *
+ * Options:
+ *   --limit <n>     Max jobs to process (default: 50)
+ *   --dry-run       Process but don't submit or update status
+ *
+ * Env vars:
+ *   NEXT_PUBLIC_SUPABASE_URL   Supabase project URL
+ *   SUPABASE_SERVICE_ROLE_KEY  Supabase service role key
+ */
+
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
+
+// ---------------------------------------------------------------------------
+// CLI arg parsing
+// ---------------------------------------------------------------------------
+
+interface CliArgs {
+  limit: number;
+  dryRun: boolean;
+}
+
+function parseArgs(): CliArgs {
+  const args = process.argv.slice(2);
+  const result: CliArgs = {
+    limit: 50,
+    dryRun: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--limit':
+        result.limit = Math.max(1, parseInt(args[++i] || '50', 10));
+        break;
+      case '--dry-run':
+        result.dryRun = true;
+        break;
+      default:
+        console.warn(`Unknown argument: ${args[i]}`);
+    }
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Supabase setup
+// ---------------------------------------------------------------------------
+
+function createSupabaseClient(): SupabaseClient {
+  const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+
+  if (!url || !key) {
+    console.error('Missing NEXT_PUBLIC_SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY');
+    process.exit(1);
+  }
+
+  return createClient(url, key);
+}
+
+// ---------------------------------------------------------------------------
+// Rate limiting
+// ---------------------------------------------------------------------------
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ---------------------------------------------------------------------------
+// Form-fill submission via Playwright
+// ---------------------------------------------------------------------------
+
+interface SubmissionResult {
+  success: boolean;
+  error?: string;
+}
+
+/**
+ * Submit a Luma registration by filling the embed form via Playwright.
+ *
+ * Luma uses invisible Cloudflare Turnstile which injects a token on form submit.
+ * Instead of trying to extract the token, we let Luma's own JS handle it by
+ * filling and submitting the form natively, then intercepting the API response.
+ */
+async function submitViaPlaywright(
+  lumaSlug: string,
+  profile: Record<string, string>,
+  customAnswers: Record<string, string>,
+): Promise<SubmissionResult> {
+  const { chromium } = await import('@playwright/test');
+
+  // Use system Chrome in headed mode — Turnstile blocks headless browsers.
+  // NOTE: Turnstile may still block Playwright-driven Chrome. If this doesn't
+  // work, consider using a CAPTCHA-solving service or a persistent browser
+  // session where the user solves Turnstile once.
+  const browser = await chromium.launch({
+    headless: false,
+    channel: 'chrome',
+    args: ['--disable-blink-features=AutomationControlled'],
+  });
+  const page = await browser.newPage();
+
+  try {
+    const embedUrl = `https://lu.ma/embed/event/${lumaSlug}/simple`;
+    await page.goto(embedUrl, { waitUntil: 'networkidle', timeout: 30000 });
+
+    // Click "Register" / "Request to Join" / "RSVP" button to open the form
+    const registerBtn = page.locator(
+      'button:has-text("Register"), button:has-text("Request to Join"), button:has-text("RSVP")'
+    );
+    const btnCount = await registerBtn.count();
+    if (btnCount === 0) {
+      return { success: false, error: 'No register button found on embed page' };
+    }
+    console.log(`    Found ${btnCount} register button(s), clicking first...`);
+    await registerBtn.first().click();
+    await page.waitForTimeout(2000);
+
+    // Fill standard fields
+    const nameInput = page.locator('input[placeholder="Your Name"], input[name="name"]').first();
+    if (await nameInput.count() > 0) {
+      const nameVal = `${profile.firstName || ''} ${profile.lastName || ''}`.trim();
+      await nameInput.fill(nameVal);
+      console.log(`    Filled name: ${nameVal}`);
+    }
+
+    const emailInput = page.locator('input[placeholder*="email"], input[type="email"], input[name="email"]').first();
+    if (await emailInput.count() > 0) {
+      await emailInput.fill(profile.email || '');
+      console.log(`    Filled email: ${profile.email}`);
+    }
+
+    // Fill custom fields by scanning the form DOM in order.
+    // Luma renders labels as div/span elements followed by the input/select.
+    // We walk through each label-like element, match it to a custom answer by
+    // question position, and fill the corresponding field.
+    //
+    // customAnswers is { questionId: value } ordered by form position.
+    const answerEntries = Object.entries(customAnswers);
+
+    // Luma renders labels with the class names we've seen.
+    // The form fields appear in order: each label div is followed by an input/select.
+    // Strategy: find all visible select + input fields (except name/email) and fill sequentially.
+
+    // 1. Fill all native <select> dropdowns
+    const selects = page.locator('select:visible');
+    const selectCount = await selects.count();
+    let selectIdx = 0;
+
+    for (let i = 0; i < selectCount; i++) {
+      const sel = selects.nth(i);
+      // Find the matching answer (look for values that exist as options)
+      for (let j = selectIdx; j < answerEntries.length; j++) {
+        const [, val] = answerEntries[j];
+        try {
+          await sel.selectOption(val);
+          console.log(`    Selected dropdown: ${val}`);
+          selectIdx = j + 1;
+          // Mark this answer as used
+          answerEntries[j] = [answerEntries[j][0], '__USED__'];
+          break;
+        } catch {
+          // This answer doesn't match this select, try next
+        }
+      }
+    }
+
+    // 2. Fill remaining text inputs with unused answers
+    const unusedAnswers = answerEntries.filter(([, v]) => v !== '__USED__');
+    let unusedIdx = 0;
+
+    const allInputs = page.locator('input:visible');
+    const inputCount = await allInputs.count();
+    for (let i = 0; i < inputCount && unusedIdx < unusedAnswers.length; i++) {
+      const input = allInputs.nth(i);
+      const val = await input.inputValue();
+      const placeholder = await input.getAttribute('placeholder') || '';
+      const type = await input.getAttribute('type') || '';
+      // Skip name, email, hidden, and already-filled inputs
+      if (placeholder.includes('Your Name') || placeholder.includes('email')) continue;
+      if (type === 'hidden' || type === 'checkbox') continue;
+      if (val) continue; // Already has a value
+
+      await input.fill(unusedAnswers[unusedIdx][1]);
+      console.log(`    Filled input: ${unusedAnswers[unusedIdx][1]}`);
+      unusedIdx++;
+    }
+
+    console.log(`    Form filled. Taking screenshot...`);
+    await page.screenshot({ path: 'batch-rsvp-filled.png' }).catch(() => {});
+    await page.waitForTimeout(1000);
+
+    // Set up response interception to capture the registration result
+    const responsePromise = page.waitForResponse(
+      (res) => res.url().includes('api.lu.ma') && res.url().includes('register'),
+      { timeout: 45000 }
+    ).catch(() => null);
+
+    // Also log all outgoing API requests for debugging
+    page.on('request', (req) => {
+      if (req.url().includes('api.lu.ma')) {
+        console.log(`    >> ${req.method()} ${req.url().slice(0, 80)}`);
+      }
+    });
+
+    // Click the submit button (it's the last "Request to Join" button on the page)
+    const submitBtn = page.locator(
+      'button:has-text("Register"), button:has-text("Request to Join"), button:has-text("Submit")'
+    ).last();
+    console.log(`    Clicking submit...`);
+    await submitBtn.click();
+
+    // Wait for the API response (give Turnstile more time)
+    console.log(`    Waiting for API response (up to 45s for Turnstile)...`);
+    const response = await responsePromise;
+    if (!response) {
+      return { success: false, error: 'No API response received (timeout or Turnstile failed)' };
+    }
+
+    const status = response.status();
+    const body = await response.json().catch(() => null);
+
+    if (status >= 200 && status < 300) {
+      return { success: true };
+    }
+
+    const errorMsg = body?.message || body?.error || body?.code || `HTTP ${status}`;
+    return { success: false, error: errorMsg };
+  } finally {
+    await browser.close();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Process a single job
+// ---------------------------------------------------------------------------
+
+async function processJob(
+  supabase: SupabaseClient,
+  job: {
+    id: number;
+    luma_slug: string;
+    event_name: string | null;
+    event_api_id: string;
+    profile_snapshot: Record<string, string>;
+    custom_answers: Record<string, string>;
+  },
+  dryRun: boolean,
+): Promise<'success' | 'failed'> {
+  const profile = job.profile_snapshot;
+
+  console.log(`  Submitting via Playwright for ${job.luma_slug}...`);
+
+  if (dryRun) {
+    console.log('  [DRY RUN] Would submit registration');
+    return 'success';
+  }
+
+  try {
+    // Mark as submitting
+    await supabase
+      .from('batch_rsvp_jobs')
+      .update({ status: 'submitting', updated_at: new Date().toISOString() })
+      .eq('id', job.id);
+
+    // Submit via Playwright (fills form + lets Luma handle Turnstile)
+    const result = await submitViaPlaywright(job.luma_slug, profile, job.custom_answers);
+
+    if (result.success) {
+      await supabase
+        .from('batch_rsvp_jobs')
+        .update({
+          status: 'success',
+          updated_at: new Date().toISOString(),
+        })
+        .eq('id', job.id);
+
+      // Also create an RSVP record so the UI shows confirmed status
+      await supabase
+        .from('rsvps')
+        .upsert({
+          user_id: (await supabase.from('batch_rsvp_jobs').select('user_id').eq('id', job.id).single()).data?.user_id,
+          event_id: (await supabase.from('batch_rsvp_jobs').select('event_id').eq('id', job.id).single()).data?.event_id,
+          status: 'confirmed',
+          method: 'batch',
+        }, { onConflict: 'user_id,event_id' });
+
+      return 'success';
+    } else {
+      await supabase
+        .from('batch_rsvp_jobs')
+        .update({
+          status: 'failed',
+          error_message: result.error || 'Unknown error',
+          updated_at: new Date().toISOString(),
+        })
+        .eq('id', job.id);
+
+      return 'failed';
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await supabase
+      .from('batch_rsvp_jobs')
+      .update({
+        status: 'failed',
+        error_message: message,
+        updated_at: new Date().toISOString(),
+      })
+      .eq('id', job.id);
+
+    return 'failed';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const args = parseArgs();
+
+  console.log('=== Batch RSVP Processor ===');
+  console.log(`  Limit: ${args.limit}`);
+  console.log(`  Dry run: ${args.dryRun}`);
+  console.log('');
+
+  const supabase = createSupabaseClient();
+
+  // Fetch pending jobs
+  const { data: jobs, error } = await supabase
+    .from('batch_rsvp_jobs')
+    .select('id, luma_slug, event_name, event_api_id, profile_snapshot, custom_answers')
+    .eq('status', 'pending')
+    .order('created_at', { ascending: true })
+    .limit(args.limit);
+
+  if (error) {
+    console.error('Failed to fetch pending jobs:', error.message);
+    process.exit(1);
+  }
+
+  if (!jobs || jobs.length === 0) {
+    console.log('No pending jobs to process.');
+    return;
+  }
+
+  console.log(`Found ${jobs.length} pending job(s)`);
+  console.log('');
+
+  let totalSuccess = 0;
+  let totalFailed = 0;
+
+  for (let i = 0; i < jobs.length; i++) {
+    const job = jobs[i];
+    const progress = `[${i + 1}/${jobs.length}]`;
+
+    console.log(`${progress} ${job.event_name || job.luma_slug}`);
+
+    const status = await processJob(supabase, job, args.dryRun);
+
+    if (status === 'success') {
+      totalSuccess++;
+      console.log('  Result: SUCCESS');
+    } else {
+      totalFailed++;
+      console.log('  Result: FAILED');
+    }
+
+    // 2s delay between submissions
+    if (i < jobs.length - 1) {
+      await delay(2000);
+    }
+  }
+
+  console.log('');
+  console.log('=== Summary ===');
+  console.log(`  Processed: ${jobs.length}`);
+  console.log(`  Success: ${totalSuccess}`);
+  console.log(`  Failed: ${totalFailed}`);
+  if (args.dryRun) {
+    console.log('  (Dry run -- no submissions made)');
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});
diff --git a/scripts/scan-luma-forms.ts b/scripts/scan-luma-forms.ts
new file mode 100644
index 00000000..6929671f
--- /dev/null
+++ b/scripts/scan-luma-forms.ts
@@ -0,0 +1,262 @@
+/**
+ * Luma form field scanning script
+ *
+ * Fetches events from Google Sheets, filters to Luma URLs,
+ * scans each event's registration form fields via the Luma API,
+ * and upserts the results into the luma_form_fields table.
+ *
+ * Usage:
+ *   npx tsx scripts/scan-luma-forms.ts [options]
+ *
+ * Options:
+ *   --conference <name>   Only scan events from the named conference
+ *   --force               Re-scan slugs already in the cache
+ *   --dry-run             Scan but don't write to Supabase
+ *
+ * Env vars:
+ *   NEXT_PUBLIC_SUPABASE_URL   Supabase project URL
+ *   SUPABASE_SERVICE_ROLE_KEY  Supabase service role key
+ */
+
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
+import { FALLBACK_TABS } from '../src/lib/conferences';
+import { getActiveConferences, conferenceToTab } from '../src/lib/conferences';
+import { fetchEvents } from '../src/lib/fetch-events';
+import type { TabConfig } from '../src/lib/conferences';
+import type { ConferenceConfig, ETHDenverEvent } from '../src/lib/types';
+import { isLumaUrl, getLumaSlug } from '../src/lib/luma';
+import { scanLumaFormFields } from '../src/lib/luma-form-scanner';
+
+// ---------------------------------------------------------------------------
+// CLI arg parsing
+// ---------------------------------------------------------------------------
+
+interface CliArgs {
+  conference: string | null;
+  force: boolean;
+  dryRun: boolean;
+}
+
+function parseArgs(): CliArgs {
+  const args = process.argv.slice(2);
+  const result: CliArgs = {
+    conference: null,
+    force: false,
+    dryRun: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--conference':
+        result.conference = args[++i] || null;
+        break;
+      case '--force':
+        result.force = true;
+        break;
+      case '--dry-run':
+        result.dryRun = true;
+        break;
+      default:
+        console.warn(`Unknown argument: ${args[i]}`);
+    }
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Supabase setup
+// ---------------------------------------------------------------------------
+
+function createSupabaseClient(): SupabaseClient {
+  const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+
+  if (!url || !key) {
+    console.error('Missing NEXT_PUBLIC_SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY');
+    process.exit(1);
+  }
+
+  return createClient(url, key);
+}
+
+// ---------------------------------------------------------------------------
+// Fetch conference tabs
+// ---------------------------------------------------------------------------
+
+async function fetchConferenceTabs(supabase: SupabaseClient): Promise<TabConfig[]> {
+  try {
+    const { data, error } = await supabase
+      .from('admin_config')
+      .select('value')
+      .eq('key', 'conferences')
+      .single();
+
+    if (error || !data?.value) {
+      console.log('No conferences config in Supabase, using FALLBACK_TABS');
+      return FALLBACK_TABS;
+    }
+
+    const allConfs = data.value as ConferenceConfig[];
+    const active = getActiveConferences(allConfs);
+    const tabs = active.map(conferenceToTab);
+    return tabs.length > 0 ? tabs : FALLBACK_TABS;
+  } catch (err) {
+    console.log('Failed to fetch from Supabase:', err);
+    return FALLBACK_TABS;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Rate limiting
+// ---------------------------------------------------------------------------
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const args = parseArgs();
+
+  console.log('=== Luma Form Scanner ===');
+  console.log(`  Conference filter: ${args.conference || 'all'}`);
+  console.log(`  Force re-scan: ${args.force}`);
+  console.log(`  Dry run: ${args.dryRun}`);
+  console.log('');
+
+  const supabase = createSupabaseClient();
+
+  // Fetch tabs
+  const allTabs = await fetchConferenceTabs(supabase);
+  let tabs = allTabs;
+
+  if (args.conference) {
+    tabs = allTabs.filter(
+      (t) =>
+        t.name.toLowerCase().includes(args.conference!.toLowerCase()) ||
+        t.slug.toLowerCase() === args.conference!.toLowerCase()
+    );
+    if (tabs.length === 0) {
+      console.error(`No conference matching "${args.conference}". Available: ${allTabs.map((t) => t.name).join(', ')}`);
+      process.exit(1);
+    }
+  }
+
+  console.log(`Using ${tabs.length} conference tab(s): ${tabs.map((t) => t.name).join(', ')}`);
+
+  // Fetch events
+  console.log('Fetching events from Google Sheets...');
+  const allEvents = await fetchEvents(undefined, tabs);
+  console.log(`  Total events: ${allEvents.length}`);
+
+  // Filter to Luma events with valid slugs
+  const lumaEvents: { event: ETHDenverEvent; slug: string }[] = [];
+  for (const event of allEvents) {
+    if (!event.link || !isLumaUrl(event.link)) continue;
+    const slug = getLumaSlug(event.link);
+    if (slug) lumaEvents.push({ event, slug });
+  }
+  console.log(`  Luma events: ${lumaEvents.length}`);
+
+  // Deduplicate by slug
+  const uniqueSlugs = new Map<string, ETHDenverEvent>();
+  for (const { event, slug } of lumaEvents) {
+    if (!uniqueSlugs.has(slug)) uniqueSlugs.set(slug, event);
+  }
+  console.log(`  Unique slugs: ${uniqueSlugs.size}`);
+
+  // Check existing scans (skip unless --force)
+  let slugsToScan = Array.from(uniqueSlugs.keys());
+
+  if (!args.force) {
+    const { data: existing } = await supabase
+      .from('luma_form_fields')
+      .select('luma_slug')
+      .in('luma_slug', slugsToScan);
+
+    const scannedSlugs = new Set((existing || []).map((r: { luma_slug: string }) => r.luma_slug));
+    slugsToScan = slugsToScan.filter((s) => !scannedSlugs.has(s));
+    console.log(`  Already scanned: ${scannedSlugs.size}`);
+  }
+
+  console.log(`  To scan: ${slugsToScan.length}`);
+  console.log('');
+
+  if (slugsToScan.length === 0) {
+    console.log('Nothing to scan. Use --force to re-scan.');
+    return;
+  }
+
+  let totalScanned = 0;
+  let totalWithQuestions = 0;
+  let totalErrors = 0;
+
+  for (let i = 0; i < slugsToScan.length; i++) {
+    const slug = slugsToScan[i];
+    const event = uniqueSlugs.get(slug)!;
+    const progress = `[${i + 1}/${slugsToScan.length}]`;
+
+    console.log(`${progress} ${event.name}`);
+    console.log(`  Slug: ${slug}`);
+
+    try {
+      const result = await scanLumaFormFields(slug);
+      totalScanned++;
+
+      if (result.questions.length > 0) {
+        totalWithQuestions++;
+        console.log(`  Found ${result.questions.length} registration question(s):`);
+        for (const q of result.questions) {
+          console.log(`    - ${q.label} (${q.question_type}${q.is_required ? ', required' : ''})`);
+        }
+      } else {
+        console.log('  No custom registration questions');
+      }
+
+      // Upsert to Supabase
+      if (!args.dryRun) {
+        const { error } = await supabase
+          .from('luma_form_fields')
+          .upsert({
+            luma_slug: slug,
+            event_api_id: result.eventApiId,
+            event_name: result.eventName,
+            name_requirement: result.nameRequirement,
+            questions: result.questions,
+            scanned_at: new Date().toISOString(),
+          }, { onConflict: 'luma_slug' });
+
+        if (error) {
+          console.error(`  Supabase upsert error: ${error.message}`);
+        }
+      }
+    } catch (err) {
+      totalErrors++;
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`  Error: ${message}`);
+    }
+
+    // Rate limit: 500ms between requests
+    if (i < slugsToScan.length - 1) {
+      await delay(500);
+    }
+  }
+
+  console.log('');
+  console.log('=== Summary ===');
+  console.log(`  Total scanned: ${totalScanned}`);
+  console.log(`  With questions: ${totalWithQuestions}`);
+  console.log(`  Errors: ${totalErrors}`);
+  if (args.dryRun) {
+    console.log('  (Dry run -- no data written to Supabase)');
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});
diff --git a/src/app/api/batch-rsvp/route.ts b/src/app/api/batch-rsvp/route.ts
new file mode 100644
index 00000000..11b4d75a
--- /dev/null
+++ b/src/app/api/batch-rsvp/route.ts
@@ -0,0 +1,163 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { createClient } from '@supabase/supabase-js';
+import { parseBody, BatchRsvpSubmitSchema } from '@/lib/api-validation';
+
+function getSupabaseAdmin() {
+  const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+  if (!url || !key) {
+    throw new Error('Missing Supabase env vars');
+  }
+  return createClient(url, key);
+}
+
+/**
+ * POST /api/batch-rsvp — Create batch RSVP jobs from wizard data.
+ *
+ * The jobs are stored with status='pending' and must be processed
+ * by the CLI script (scripts/process-batch-rsvp.ts) which uses
+ * Playwright to solve the Turnstile captcha.
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const { data, error } = await parseBody(request, BatchRsvpSubmitSchema);
+    if (error) return error;
+
+    // Get the user from the Authorization header (Supabase anon key auth)
+    const authHeader = request.headers.get('authorization');
+    if (!authHeader?.startsWith('Bearer ')) {
+      return NextResponse.json(
+        { error: 'Authentication required' },
+        { status: 401 }
+      );
+    }
+
+    const supabaseAdmin = getSupabaseAdmin();
+
+    // Verify the JWT to get the user ID
+    const token = authHeader.slice(7);
+    const { data: userData, error: authError } = await supabaseAdmin.auth.getUser(token);
+    if (authError || !userData?.user) {
+      return NextResponse.json(
+        { error: 'Invalid or expired token' },
+        { status: 401 }
+      );
+    }
+
+    const userId = userData.user.id;
+
+    // Build the profile snapshot
+    const profileSnapshot: Record<string, string> = {
+      email: data.profile.email,
+      firstName: data.profile.firstName,
+      lastName: data.profile.lastName,
+    };
+    if (data.profile.company) profileSnapshot.company = data.profile.company;
+    if (data.profile.jobTitle) profileSnapshot.jobTitle = data.profile.jobTitle;
+    if (data.profile.phone) profileSnapshot.phone = data.profile.phone;
+    if (data.profile.telegram) profileSnapshot.telegram = data.profile.telegram;
+    if (data.profile.xHandle) profileSnapshot.xHandle = data.profile.xHandle;
+    if (data.profile.linkedin) profileSnapshot.linkedin = data.profile.linkedin;
+    if (data.profile.website) profileSnapshot.website = data.profile.website;
+
+    // Insert batch jobs
+    const rows = data.events.map((event) => ({
+      user_id: userId,
+      event_id: event.eventId,
+      luma_slug: event.lumaSlug,
+      event_name: event.eventName,
+      event_api_id: event.eventApiId,
+      status: 'pending',
+      profile_snapshot: profileSnapshot,
+      custom_answers: event.customAnswers || {},
+    }));
+
+    const { data: insertedJobs, error: insertError } = await supabaseAdmin
+      .from('batch_rsvp_jobs')
+      .insert(rows)
+      .select('id, event_id, event_name, status');
+
+    if (insertError) {
+      console.error('Batch RSVP insert error:', insertError);
+      return NextResponse.json(
+        { error: 'Failed to create batch RSVP jobs' },
+        { status: 500 }
+      );
+    }
+
+    const jobs = insertedJobs ?? [];
+    return NextResponse.json({
+      jobs,
+      message: `Created ${jobs.length} RSVP job(s). They will be processed shortly.`,
+    });
+  } catch (err) {
+    console.error('Batch RSVP error:', err);
+    return NextResponse.json(
+      { error: 'Failed to create batch RSVP jobs' },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * GET /api/batch-rsvp?ids=1,2,3 — Poll job statuses.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const idsParam = request.nextUrl.searchParams.get('ids');
+    if (!idsParam) {
+      return NextResponse.json(
+        { error: 'Missing ids parameter' },
+        { status: 400 }
+      );
+    }
+
+    const ids = idsParam.split(',').map(Number).filter(Boolean);
+    if (ids.length === 0 || ids.length > 50) {
+      return NextResponse.json(
+        { error: 'Invalid ids (1-50 required)' },
+        { status: 400 }
+      );
+    }
+
+    const authHeader = request.headers.get('authorization');
+    if (!authHeader?.startsWith('Bearer ')) {
+      return NextResponse.json(
+        { error: 'Authentication required' },
+        { status: 401 }
+      );
+    }
+
+    const supabaseAdmin = getSupabaseAdmin();
+
+    const token = authHeader.slice(7);
+    const { data: userData, error: authError } = await supabaseAdmin.auth.getUser(token);
+    if (authError || !userData?.user) {
+      return NextResponse.json(
+        { error: 'Invalid or expired token' },
+        { status: 401 }
+      );
+    }
+
+    const { data: jobs, error: queryError } = await supabaseAdmin
+      .from('batch_rsvp_jobs')
+      .select('id, event_id, event_name, status, error_message, updated_at')
+      .eq('user_id', userData.user.id)
+      .in('id', ids);
+
+    if (queryError) {
+      return NextResponse.json(
+        { error: 'Failed to fetch job statuses' },
+        { status: 500 }
+      );
+    }
+
+    return NextResponse.json({ jobs });
+  } catch (err) {
+    console.error('Batch RSVP GET error:', err);
+    return NextResponse.json(
+      { error: 'Failed to fetch job statuses' },
+      { status: 500 }
+    );
+  }
+}
diff --git a/src/app/api/luma/scan-form/route.ts b/src/app/api/luma/scan-form/route.ts
new file mode 100644
index 00000000..85d170af
--- /dev/null
+++ b/src/app/api/luma/scan-form/route.ts
@@ -0,0 +1,62 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { createClient } from '@supabase/supabase-js';
+import { parseBody, ScanFormFieldsSchema } from '@/lib/api-validation';
+import { scanLumaFormFields, type ScannedFormResult } from '@/lib/luma-form-scanner';
+
+interface ScanResult {
+  slug: string;
+  result?: ScannedFormResult;
+  error?: string;
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    // Require authentication to prevent abuse
+    const authHeader = request.headers.get('authorization');
+    if (!authHeader?.startsWith('Bearer ')) {
+      return NextResponse.json(
+        { error: 'Authentication required' },
+        { status: 401 }
+      );
+    }
+
+    const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+    const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+    if (url && key) {
+      const supabase = createClient(url, key);
+      const token = authHeader.slice(7);
+      const { error: authError } = await supabase.auth.getUser(token);
+      if (authError) {
+        return NextResponse.json(
+          { error: 'Invalid or expired token' },
+          { status: 401 }
+        );
+      }
+    }
+
+    const { data, error } = await parseBody(request, ScanFormFieldsSchema);
+    if (error) return error;
+
+    const { slugs } = data;
+
+    const results: ScanResult[] = await Promise.all(
+      slugs.map(async (slug): Promise<ScanResult> => {
+        try {
+          const result = await scanLumaFormFields(slug);
+          return { slug, result };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { slug, error: message };
+        }
+      })
+    );
+
+    return NextResponse.json({ results });
+  } catch (err) {
+    console.error('Luma scan-form error:', err);
+    return NextResponse.json(
+      { error: 'Failed to scan form fields' },
+      { status: 500 }
+    );
+  }
+}
diff --git a/src/components/BatchRsvpModal.tsx b/src/components/BatchRsvpModal.tsx
new file mode 100644
index 00000000..3ba2c40d
--- /dev/null
+++ b/src/components/BatchRsvpModal.tsx
@@ -0,0 +1,745 @@
+'use client';
+
+import { useEffect, useCallback, useState } from 'react';
+import { createPortal } from 'react-dom';
+import {
+  X, CheckCircle, Clock, Loader2, AlertTriangle,
+  ChevronDown, ChevronRight, Mail, User, Building2,
+  Briefcase, Phone, Globe, Send, Linkedin,
+} from 'lucide-react';
+import { useBatchRsvp, type BatchProfileData } from '@/hooks/useBatchRsvp';
+import { useProfile } from '@/hooks/useProfile';
+import { isLumaUrl } from '@/lib/luma';
+import type { ETHDenverEvent } from '@/lib/types';
+
+// ---------------------------------------------------------------------------
+// Props
+// ---------------------------------------------------------------------------
+
+interface BatchRsvpModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  events: ETHDenverEvent[];
+  itinerary: Set<string>;
+  confirmedIds: Set<string>;
+}
+
+// ---------------------------------------------------------------------------
+// Component
+// ---------------------------------------------------------------------------
+
+export function BatchRsvpModal({
+  isOpen,
+  onClose,
+  events,
+  itinerary,
+  confirmedIds,
+}: BatchRsvpModalProps) {
+  const {
+    step,
+    selectedEventIds,
+    scannedEvents,
+    scanning,
+    profileData,
+    customAnswers,
+    jobStatuses,
+    selectEvent,
+    selectAll,
+    deselectAll,
+    setProfileField,
+    setAnswer,
+    scanSelectedEvents,
+    nextStep,
+    prevStep,
+    submit,
+    reset,
+    stopPolling,
+  } = useBatchRsvp();
+
+  const { profile, updateProfile } = useProfile();
+
+  // Luma events in itinerary that aren't already RSVP'd
+  const eligibleEvents = events.filter(
+    (e) => itinerary.has(e.id) && isLumaUrl(e.link) && !confirmedIds.has(e.id)
+  );
+
+  const handleClose = useCallback(() => {
+    stopPolling();
+    reset();
+    onClose();
+  }, [stopPolling, reset, onClose]);
+
+  // Pre-fill profile data from existing profile
+  useEffect(() => {
+    if (profile && isOpen) {
+      setProfileField('email', profile.email || '');
+      setProfileField('firstName', profile.first_name || '');
+      setProfileField('lastName', profile.last_name || '');
+      setProfileField('company', profile.company || '');
+      setProfileField('jobTitle', profile.job_title || '');
+      setProfileField('phone', profile.phone || '');
+      setProfileField('telegram', profile.telegram_handle || '');
+      setProfileField('xHandle', profile.x_handle || '');
+      setProfileField('linkedin', profile.linkedin_url || '');
+      setProfileField('website', profile.website || '');
+    }
+  }, [profile, isOpen, setProfileField]);
+
+  // Close on Escape key
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') handleClose();
+    };
+    document.addEventListener('keydown', handleKeyDown);
+    return () => document.removeEventListener('keydown', handleKeyDown);
+  }, [isOpen, handleClose]);
+
+  // Lock body scroll + cleanup polling on unmount
+  useEffect(() => {
+    if (!isOpen) return;
+    document.body.style.overflow = 'hidden';
+    return () => {
+      document.body.style.overflow = '';
+      stopPolling();
+    };
+  }, [isOpen, stopPolling]);
+
+  // Trigger scan when moving from select -> profile
+  const handleNextFromSelect = useCallback(async () => {
+    await scanSelectedEvents(eligibleEvents);
+    nextStep();
+  }, [scanSelectedEvents, eligibleEvents, nextStep]);
+
+  // Save profile field on blur
+  const handleProfileBlur = useCallback(
+    (field: keyof BatchProfileData) => {
+      const fieldMap: Partial<Record<keyof BatchProfileData, string>> = {
+        firstName: 'first_name',
+        lastName: 'last_name',
+        company: 'company',
+        jobTitle: 'job_title',
+        phone: 'phone',
+        telegram: 'telegram_handle',
+        xHandle: 'x_handle',
+        linkedin: 'linkedin_url',
+        website: 'website',
+      };
+
+      const dbField = fieldMap[field];
+      if (dbField && profileData[field]) {
+        updateProfile({ [dbField]: profileData[field] } as Record<string, string>);
+      }
+    },
+    [profileData, updateProfile]
+  );
+
+  if (!isOpen) return null;
+
+  const stepTitles: Record<string, string> = {
+    select: 'Select Events',
+    profile: 'Your Info',
+    custom: 'Just a few more details',
+    review: 'Review & Submit',
+    submitting: 'Submitting...',
+    results: 'Results',
+  };
+
+  return createPortal(
+    <div
+      className="fixed inset-0 z-[90] flex items-end sm:items-center justify-center"
+      onClick={handleClose}
+    >
+      <div className="absolute inset-0 bg-black/60" />
+
+      <div
+        className="relative w-full sm:max-w-lg bg-[var(--theme-bg-secondary)] border border-[var(--theme-border-primary)] rounded-t-2xl sm:rounded-xl shadow-2xl flex flex-col"
+        style={{ height: '85vh', maxHeight: '85vh' }}
+        onClick={(e) => e.stopPropagation()}
+      >
+        {/* Header */}
+        <div className="flex items-center justify-between px-4 py-3 border-b border-[var(--theme-border-primary)] shrink-0">
+          <div>
+            <h2 className="text-sm font-bold text-[var(--theme-text-primary)]">
+              Batch RSVP
+            </h2>
+            <p className="text-xs text-[var(--theme-text-secondary)]">
+              {stepTitles[step] || ''}
+            </p>
+          </div>
+          <button
+            onClick={handleClose}
+            className="p-1 text-[var(--theme-text-secondary)] hover:text-[var(--theme-text-primary)] transition-colors cursor-pointer"
+            aria-label="Close"
+          >
+            <X className="w-5 h-5" />
+          </button>
+        </div>
+
+        {/* Step content */}
+        <div className="flex-1 min-h-0 overflow-y-auto p-4">
+          {step === 'select' && (
+            <SelectStep
+              events={eligibleEvents}
+              selectedIds={selectedEventIds}
+              onSelect={selectEvent}
+              onSelectAll={() => selectAll(eligibleEvents.map((e) => e.id))}
+              onDeselectAll={deselectAll}
+            />
+          )}
+          {step === 'profile' && (
+            <ProfileStep
+              data={profileData}
+              onChange={setProfileField}
+              onBlur={handleProfileBlur}
+              scanning={scanning}
+            />
+          )}
+          {step === 'custom' && (
+            <CustomFieldsStep
+              selectedEventIds={selectedEventIds}
+              scannedEvents={scannedEvents}
+              customAnswers={customAnswers}
+              onSetAnswer={setAnswer}
+            />
+          )}
+          {(step === 'review' || step === 'submitting') && (
+            <ReviewStep
+              selectedEventIds={selectedEventIds}
+              scannedEvents={scannedEvents}
+              profileData={profileData}
+              submitting={step === 'submitting'}
+            />
+          )}
+          {step === 'results' && (
+            <ResultsStep
+              jobStatuses={jobStatuses}
+            />
+          )}
+        </div>
+
+        {/* Footer buttons */}
+        <div className="flex items-center gap-3 px-4 py-3 border-t border-[var(--theme-border-primary)] bg-[var(--theme-bg-secondary)] shrink-0">
+          {step === 'select' && (
+            <>
+              <button
+                onClick={handleClose}
+                className="flex-1 px-4 py-2.5 rounded-lg border border-[var(--theme-border-primary)] text-[var(--theme-text-secondary)] hover:text-[var(--theme-text-primary)] hover:bg-[var(--theme-bg-tertiary)] text-sm font-medium transition-colors cursor-pointer"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={handleNextFromSelect}
+                disabled={selectedEventIds.size === 0}
+                className="flex-1 px-4 py-2.5 rounded-lg bg-orange-600 hover:bg-orange-500 disabled:opacity-40 disabled:cursor-not-allowed text-white text-sm font-semibold transition-colors cursor-pointer"
+              >
+                Next ({selectedEventIds.size} selected)
+              </button>
+            </>
+          )}
+          {(step === 'profile' || step === 'custom') && (
+            <>
+              <button
+                onClick={prevStep}
+                className="flex-1 px-4 py-2.5 rounded-lg border border-[var(--theme-border-primary)] text-[var(--theme-text-secondary)] hover:text-[var(--theme-text-primary)] hover:bg-[var(--theme-bg-tertiary)] text-sm font-medium transition-colors cursor-pointer"
+              >
+                Back
+              </button>
+              <button
+                onClick={nextStep}
+                disabled={step === 'profile' && (!profileData.email || !profileData.firstName || !profileData.lastName)}
+                className="flex-1 px-4 py-2.5 rounded-lg bg-orange-600 hover:bg-orange-500 disabled:opacity-40 disabled:cursor-not-allowed text-white text-sm font-semibold transition-colors cursor-pointer"
+              >
+                Next
+              </button>
+            </>
+          )}
+          {step === 'review' && (
+            <>
+              <button
+                onClick={prevStep}
+                className="flex-1 px-4 py-2.5 rounded-lg border border-[var(--theme-border-primary)] text-[var(--theme-text-secondary)] hover:text-[var(--theme-text-primary)] hover:bg-[var(--theme-bg-tertiary)] text-sm font-medium transition-colors cursor-pointer"
+              >
+                Back
+              </button>
+              <button
+                onClick={submit}
+                className="flex-1 px-4 py-2.5 rounded-lg bg-green-600 hover:bg-green-500 text-white text-sm font-semibold transition-colors cursor-pointer"
+              >
+                Submit RSVPs
+              </button>
+            </>
+          )}
+          {step === 'submitting' && (
+            <div className="flex-1 flex items-center justify-center gap-2 py-2.5 text-sm text-[var(--theme-text-secondary)]">
+              <Loader2 className="w-4 h-4 animate-spin" />
+              Creating RSVP jobs...
+            </div>
+          )}
+          {step === 'results' && (
+            <button
+              onClick={handleClose}
+              className="flex-1 px-4 py-2.5 rounded-lg bg-[var(--theme-accent)] hover:bg-[var(--theme-accent-hover)] text-[var(--theme-accent-text)] text-sm font-semibold transition-colors cursor-pointer"
+            >
+              Done
+            </button>
+          )}
+        </div>
+      </div>
+    </div>,
+    document.body
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Step 1: Select Events
+// ---------------------------------------------------------------------------
+
+function SelectStep({
+  events,
+  selectedIds,
+  onSelect,
+  onSelectAll,
+  onDeselectAll,
+}: {
+  events: ETHDenverEvent[];
+  selectedIds: Set<string>;
+  onSelect: (id: string) => void;
+  onSelectAll: () => void;
+  onDeselectAll: () => void;
+}) {
+  if (events.length === 0) {
+    return (
+      <div className="flex flex-col items-center justify-center py-12 text-center">
+        <p className="text-[var(--theme-text-secondary)] text-sm">
+          No Luma events in your itinerary that need RSVPs.
+        </p>
+        <p className="text-[var(--theme-text-muted)] text-xs mt-1">
+          Add some Luma events to your itinerary first.
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center justify-between">
+        <span className="text-xs text-[var(--theme-text-muted)]">
+          {selectedIds.size} of {events.length} selected
+        </span>
+        <div className="flex gap-2">
+          <button
+            onClick={onSelectAll}
+            className="text-xs text-orange-400 hover:text-orange-300 transition-colors cursor-pointer"
+          >
+            Select all
+          </button>
+          <span className="text-xs text-[var(--theme-text-muted)]">|</span>
+          <button
+            onClick={onDeselectAll}
+            className="text-xs text-[var(--theme-text-muted)] hover:text-[var(--theme-text-secondary)] transition-colors cursor-pointer"
+          >
+            Deselect all
+          </button>
+        </div>
+      </div>
+
+      {events.map((event) => (
+        <label
+          key={event.id}
+          className="flex items-start gap-3 p-3 rounded-lg border border-[var(--theme-border-primary)] hover:bg-[var(--theme-bg-tertiary)] transition-colors cursor-pointer"
+        >
+          <input
+            type="checkbox"
+            checked={selectedIds.has(event.id)}
+            onChange={() => onSelect(event.id)}
+            className="mt-0.5 accent-orange-500"
+          />
+          <div className="min-w-0 flex-1">
+            <p className="text-sm font-medium text-[var(--theme-text-primary)] truncate">
+              {event.name}
+            </p>
+            <p className="text-xs text-[var(--theme-text-secondary)]">
+              {event.date} {event.startTime && `- ${event.startTime}`}
+            </p>
+            <p className="text-xs text-[var(--theme-text-muted)] truncate">
+              {event.organizer}
+            </p>
+          </div>
+        </label>
+      ))}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Step 2: Profile Info
+// ---------------------------------------------------------------------------
+
+function ProfileStep({
+  data,
+  onChange,
+  onBlur,
+  scanning,
+}: {
+  data: BatchProfileData;
+  onChange: (field: keyof BatchProfileData, value: string) => void;
+  onBlur: (field: keyof BatchProfileData) => void;
+  scanning: boolean;
+}) {
+  const fields: { key: keyof BatchProfileData; label: string; icon: React.ReactNode; required?: boolean; type?: string }[] = [
+    { key: 'email', label: 'Email', icon: <Mail className="w-4 h-4" />, required: true, type: 'email' },
+    { key: 'firstName', label: 'First Name', icon: <User className="w-4 h-4" />, required: true },
+    { key: 'lastName', label: 'Last Name', icon: <User className="w-4 h-4" />, required: true },
+    { key: 'company', label: 'Company', icon: <Building2 className="w-4 h-4" /> },
+    { key: 'jobTitle', label: 'Job Title', icon: <Briefcase className="w-4 h-4" /> },
+    { key: 'telegram', label: 'Telegram', icon: <Send className="w-4 h-4" /> },
+    { key: 'xHandle', label: 'X Handle', icon: <span className="text-xs font-bold leading-none w-4 text-center">X</span> },
+    { key: 'linkedin', label: 'LinkedIn', icon: <Linkedin className="w-4 h-4" /> },
+    { key: 'phone', label: 'Phone', icon: <Phone className="w-4 h-4" />, type: 'tel' },
+    { key: 'website', label: 'Website', icon: <Globe className="w-4 h-4" />, type: 'url' },
+  ];
+
+  return (
+    <div className="space-y-3">
+      {scanning && (
+        <div className="flex items-center gap-2 p-3 rounded-lg bg-blue-500/10 border border-blue-500/20">
+          <Loader2 className="w-4 h-4 animate-spin text-blue-400" />
+          <span className="text-xs text-blue-300">Scanning event registration forms...</span>
+        </div>
+      )}
+
+      <p className="text-xs text-[var(--theme-text-muted)]">
+        Saved for future events
+      </p>
+
+      {fields.map(({ key, label, icon, required, type }) => (
+        <div key={key} className="flex items-center gap-2">
+          <span className="text-[var(--theme-text-muted)] shrink-0">{icon}</span>
+          <input
+            type={type || 'text'}
+            value={data[key]}
+            onChange={(e) => onChange(key, e.target.value)}
+            onBlur={() => onBlur(key)}
+            placeholder={`${label}${required ? ' *' : ''}`}
+            className="flex-1 bg-[var(--theme-bg-tertiary)] border border-[var(--theme-border-primary)] rounded-lg px-3 py-2 text-sm text-[var(--theme-text-primary)] placeholder:text-[var(--theme-text-muted)] focus:outline-none focus:border-orange-500/50"
+          />
+        </div>
+      ))}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Step 3: Custom Fields
+// ---------------------------------------------------------------------------
+
+function CustomFieldsStep({
+  selectedEventIds,
+  scannedEvents,
+  customAnswers,
+  onSetAnswer,
+}: {
+  selectedEventIds: Set<string>;
+  scannedEvents: Map<string, { event: ETHDenverEvent; formResult: { questions: { id: string; label: string; question_type: string; is_required: boolean; options?: string[]; terms_content?: string }[] } | null }>;
+  customAnswers: Map<string, Map<string, string>>;
+  onSetAnswer: (eventId: string, questionId: string, answer: string) => void;
+}) {
+  const [collapsed, setCollapsed] = useState<Set<string>>(new Set());
+
+  const toggleCollapse = useCallback((eventId: string) => {
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      if (next.has(eventId)) next.delete(eventId);
+      else next.add(eventId);
+      return next;
+    });
+  }, []);
+
+  const eventsWithQuestions = Array.from(selectedEventIds)
+    .map((id) => scannedEvents.get(id))
+    .filter((s): s is NonNullable<typeof s> => !!s?.formResult?.questions?.length);
+
+  if (eventsWithQuestions.length === 0) {
+    return (
+      <div className="flex flex-col items-center justify-center py-12 text-center">
+        <CheckCircle className="w-8 h-8 text-green-400 mb-3" />
+        <p className="text-[var(--theme-text-secondary)] text-sm">
+          No custom fields needed!
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-4">
+      {eventsWithQuestions.map((scanned) => {
+        const isCollapsed = collapsed.has(scanned.event.id);
+        const eventAnswers = customAnswers.get(scanned.event.id);
+
+        return (
+          <div
+            key={scanned.event.id}
+            className="border border-[var(--theme-border-primary)] rounded-lg overflow-hidden"
+          >
+            <button
+              onClick={() => toggleCollapse(scanned.event.id)}
+              className="w-full flex items-center gap-2 px-3 py-2.5 bg-[var(--theme-bg-tertiary)] text-left cursor-pointer hover:bg-[var(--theme-bg-tertiary)]/80 transition-colors"
+            >
+              {isCollapsed ? (
+                <ChevronRight className="w-4 h-4 text-[var(--theme-text-muted)] shrink-0" />
+              ) : (
+                <ChevronDown className="w-4 h-4 text-[var(--theme-text-muted)] shrink-0" />
+              )}
+              <span className="text-sm font-medium text-[var(--theme-text-primary)] truncate">
+                {scanned.event.name}
+              </span>
+              <span className="text-xs text-[var(--theme-text-muted)] shrink-0 ml-auto">
+                {scanned.formResult!.questions.length} field(s)
+              </span>
+            </button>
+
+            {!isCollapsed && (
+              <div className="p-3 space-y-3">
+                {scanned.formResult!.questions.map((q) => (
+                  <CustomFieldInput
+                    key={q.id}
+                    question={q}
+                    value={eventAnswers?.get(q.id) || ''}
+                    onChange={(val) => onSetAnswer(scanned.event.id, q.id, val)}
+                  />
+                ))}
+              </div>
+            )}
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+function CustomFieldInput({
+  question,
+  value,
+  onChange,
+}: {
+  question: { id: string; label: string; question_type: string; is_required: boolean; options?: string[]; terms_content?: string };
+  value: string;
+  onChange: (val: string) => void;
+}) {
+  const label = `${question.label}${question.is_required ? ' *' : ''}`;
+
+  if (question.question_type === 'dropdown' && question.options) {
+    return (
+      <div>
+        <label className="block text-xs text-[var(--theme-text-secondary)] mb-1">{label}</label>
+        <select
+          value={value}
+          onChange={(e) => onChange(e.target.value)}
+          className="w-full bg-[var(--theme-bg-tertiary)] border border-[var(--theme-border-primary)] rounded-lg px-3 py-2 text-sm text-[var(--theme-text-primary)] focus:outline-none focus:border-orange-500/50"
+        >
+          <option value="">Select...</option>
+          {question.options.map((opt) => (
+            <option key={opt} value={opt}>{opt}</option>
+          ))}
+        </select>
+      </div>
+    );
+  }
+
+  if (question.question_type === 'multi-select' && question.options) {
+    const selected = new Set(value ? value.split(',') : []);
+    return (
+      <div>
+        <label className="block text-xs text-[var(--theme-text-secondary)] mb-1">{label}</label>
+        <div className="space-y-1">
+          {question.options.map((opt) => (
+            <label key={opt} className="flex items-center gap-2 text-sm text-[var(--theme-text-primary)] cursor-pointer">
+              <input
+                type="checkbox"
+                checked={selected.has(opt)}
+                onChange={() => {
+                  const next = new Set(selected);
+                  if (next.has(opt)) next.delete(opt);
+                  else next.add(opt);
+                  onChange(Array.from(next).join(','));
+                }}
+                className="accent-orange-500"
+              />
+              {opt}
+            </label>
+          ))}
+        </div>
+      </div>
+    );
+  }
+
+  if (question.question_type === 'terms') {
+    return (
+      <label className="flex items-start gap-2 cursor-pointer">
+        <input
+          type="checkbox"
+          checked={value === 'true'}
+          onChange={(e) => onChange(e.target.checked ? 'true' : '')}
+          className="mt-0.5 accent-orange-500"
+        />
+        <span className="text-xs text-[var(--theme-text-secondary)]">
+          {question.terms_content || question.label}
+        </span>
+      </label>
+    );
+  }
+
+  // Default: text input
+  return (
+    <div>
+      <label className="block text-xs text-[var(--theme-text-secondary)] mb-1">{label}</label>
+      <input
+        type="text"
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+        placeholder={question.label}
+        className="w-full bg-[var(--theme-bg-tertiary)] border border-[var(--theme-border-primary)] rounded-lg px-3 py-2 text-sm text-[var(--theme-text-primary)] placeholder:text-[var(--theme-text-muted)] focus:outline-none focus:border-orange-500/50"
+      />
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Step 4: Review & Submit
+// ---------------------------------------------------------------------------
+
+function ReviewStep({
+  selectedEventIds,
+  scannedEvents,
+  profileData,
+  submitting,
+}: {
+  selectedEventIds: Set<string>;
+  scannedEvents: Map<string, { event: ETHDenverEvent; formResult: { eventApiId: string } | null }>;
+  profileData: BatchProfileData;
+  submitting: boolean;
+}) {
+  return (
+    <div className="space-y-4">
+      {/* Profile summary */}
+      <div className="p-3 rounded-lg bg-[var(--theme-bg-tertiary)] border border-[var(--theme-border-primary)]">
+        <p className="text-xs font-medium text-[var(--theme-text-secondary)] mb-2">Submitting as:</p>
+        <p className="text-sm text-[var(--theme-text-primary)]">
+          {profileData.firstName} {profileData.lastName}
+        </p>
+        <p className="text-xs text-[var(--theme-text-muted)]">{profileData.email}</p>
+        {profileData.company && (
+          <p className="text-xs text-[var(--theme-text-muted)]">{profileData.company}</p>
+        )}
+      </div>
+
+      {/* Event list */}
+      <div className="space-y-2">
+        <p className="text-xs font-medium text-[var(--theme-text-secondary)]">
+          {selectedEventIds.size} event(s):
+        </p>
+        {Array.from(selectedEventIds).map((eventId) => {
+          const scanned = scannedEvents.get(eventId);
+          if (!scanned) return null;
+          return (
+            <div
+              key={eventId}
+              className="flex items-center gap-2 p-2 rounded-lg border border-[var(--theme-border-primary)]"
+            >
+              {submitting ? (
+                <Loader2 className="w-4 h-4 animate-spin text-blue-400 shrink-0" />
+              ) : (
+                <Clock className="w-4 h-4 text-[var(--theme-text-muted)] shrink-0" />
+              )}
+              <span className="text-sm text-[var(--theme-text-primary)] truncate">
+                {scanned.event.name}
+              </span>
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Step 5: Results
+// ---------------------------------------------------------------------------
+
+function ResultsStep({ jobStatuses }: { jobStatuses: { id: number; eventId: string; eventName: string; status: string; errorMessage?: string }[] }) {
+  const statusIcon = (status: string) => {
+    switch (status) {
+      case 'pending':
+        return <Clock className="w-4 h-4 text-yellow-400 shrink-0" />;
+      case 'submitting':
+        return <Loader2 className="w-4 h-4 animate-spin text-blue-400 shrink-0" />;
+      case 'success':
+        return <CheckCircle className="w-4 h-4 text-green-400 shrink-0" />;
+      case 'failed':
+        return <AlertTriangle className="w-4 h-4 text-red-400 shrink-0" />;
+      default:
+        return <Clock className="w-4 h-4 text-[var(--theme-text-muted)] shrink-0" />;
+    }
+  };
+
+  const successCount = jobStatuses.filter((j) => j.status === 'success').length;
+  const failedCount = jobStatuses.filter((j) => j.status === 'failed').length;
+  const pendingCount = jobStatuses.filter((j) => j.status === 'pending' || j.status === 'submitting').length;
+
+  return (
+    <div className="space-y-4">
+      {/* Summary */}
+      <div className="flex items-center gap-3 p-3 rounded-lg bg-[var(--theme-bg-tertiary)] border border-[var(--theme-border-primary)]">
+        {pendingCount > 0 ? (
+          <>
+            <Loader2 className="w-5 h-5 animate-spin text-blue-400" />
+            <span className="text-sm text-[var(--theme-text-primary)]">
+              Processing... {successCount} done, {pendingCount} remaining
+            </span>
+          </>
+        ) : failedCount > 0 ? (
+          <>
+            <AlertTriangle className="w-5 h-5 text-yellow-400" />
+            <span className="text-sm text-[var(--theme-text-primary)]">
+              {successCount} succeeded, {failedCount} failed
+            </span>
+          </>
+        ) : (
+          <>
+            <CheckCircle className="w-5 h-5 text-green-400" />
+            <span className="text-sm text-[var(--theme-text-primary)]">
+              All {successCount} RSVPs submitted!
+            </span>
+          </>
+        )}
+      </div>
+
+      {/* Job list */}
+      <div className="space-y-2">
+        {jobStatuses.map((job) => (
+          <div
+            key={job.id}
+            className="flex items-start gap-2 p-2 rounded-lg border border-[var(--theme-border-primary)]"
+          >
+            {statusIcon(job.status)}
+            <div className="min-w-0 flex-1">
+              <p className="text-sm text-[var(--theme-text-primary)] truncate">
+                {job.eventName}
+              </p>
+              {job.errorMessage && (
+                <p className="text-xs text-red-400 mt-0.5">{job.errorMessage}</p>
+              )}
+            </div>
+          </div>
+        ))}
+      </div>
+
+      {pendingCount > 0 && (
+        <p className="text-xs text-[var(--theme-text-muted)] text-center">
+          Jobs are processed by a background worker. You can close this and check back later.
+        </p>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/EventApp.tsx b/src/components/EventApp.tsx
index c14b2e1d..9d3e274a 100644
--- a/src/components/EventApp.tsx
+++ b/src/components/EventApp.tsx
@@ -46,6 +46,8 @@ import { useAuth } from '@/contexts/AuthContext';
 import { useRsvp } from '@/hooks/useRsvp';
 import { useProfile } from '@/hooks/useProfile';
 import { RsvpOverlay } from './RsvpOverlay';
+import { BatchRsvpModal } from './BatchRsvpModal';
+import { isLumaUrl } from '@/lib/luma';
 
 export function EventApp({ initialConference, initialEvents }: { initialConference?: string; initialEvents?: ETHDenverEvent[] }) {
   const { config } = useAdminConfig();
@@ -168,9 +170,20 @@ export function EventApp({ initialConference, initialEvents }: { initialConferen
     clearResult: clearCheckInResult,
   } = useEventCheckIn();
 
-  const { getRsvpStatus, openRsvp, confirmRsvp, closeRsvp, activeRsvp } = useRsvp();
+  const { getRsvpStatus, openRsvp, confirmRsvp, closeRsvp, activeRsvp, confirmedIds } = useRsvp();
   const { profile } = useProfile();
 
+  // Batch RSVP: count eligible Luma events in itinerary that aren't RSVP'd yet
+  const batchRsvpEligibleCount = useMemo(() => {
+    let count = 0;
+    for (const e of events) {
+      if (itinerary.has(e.id) && isLumaUrl(e.link) && !confirmedIds.has(e.id)) {
+        count++;
+      }
+    }
+    return count;
+  }, [events, itinerary, confirmedIds]);
+
   const liveEventIds = useMemo(() => {
     const now = getConferenceNow(filters.conference);
     const nowMinutes = now.getHours() * 60 + now.getMinutes();
@@ -359,6 +372,7 @@ export function EventApp({ initialConference, initialEvents }: { initialConferen
   const [showFriends, setShowFriends] = useState(false);
   const [showSubmitEvent, setShowSubmitEvent] = useState(false);
   const [showSignIn, setShowSignIn] = useState(false);
+  const [showBatchRsvp, setShowBatchRsvp] = useState(false);
 
   // Friend code (?fc=) URL handler
   const { toast: friendCodeToast } = useFriendCode({
@@ -648,6 +662,20 @@ export function EventApp({ initialConference, initialEvents }: { initialConferen
         />
       )}
 
+      {/* Batch RSVP FAB: visible when logged in with eligible Luma events */}
+      {authUser && batchRsvpEligibleCount > 0 && (
+        <button
+          onClick={() => setShowBatchRsvp(true)}
+          className={`fixed right-6 z-[60] flex items-center gap-2 px-4 py-2.5 rounded-full bg-orange-600 hover:bg-orange-500 text-white text-sm font-semibold shadow-lg transition-colors cursor-pointer ${hasNearbyLiveEvents ? 'bottom-20' : 'bottom-6'}`}
+          title={`Batch RSVP to ${batchRsvpEligibleCount} event(s)`}
+        >
+          <svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+            <path strokeLinecap="round" strokeLinejoin="round" d="M3 8l7.89 5.26a2 2 0 002.22 0L21 8M5 19h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v10a2 2 0 002 2z" />
+          </svg>
+          Batch RSVP ({batchRsvpEligibleCount})
+        </button>
+      )}
+
       <AuthModal isOpen={showAuthForStar || showSignIn} onClose={handleCloseAuth} />
       <SubmitEventModal isOpen={showSubmitEvent} onClose={handleCloseSubmitEvent} upsellCopy={config?.upsell_copy} initialConference={filters.conference} conferenceTabs={conferenceTabs} />
       <FriendsPanel
@@ -681,6 +709,13 @@ export function EventApp({ initialConference, initialEvents }: { initialConferen
           onClose={closeRsvp}
         />
       )}
+      <BatchRsvpModal
+        isOpen={showBatchRsvp}
+        onClose={() => setShowBatchRsvp(false)}
+        events={events}
+        itinerary={itinerary}
+        confirmedIds={confirmedIds}
+      />
       {friendCodeToast && (
         <div className={`fixed bottom-6 left-1/2 -translate-x-1/2 z-[9999] px-4 py-3 rounded-lg shadow-lg text-sm font-medium transition-opacity duration-300 ${
           friendCodeToast.type === 'success'
diff --git a/src/components/RsvpButton.tsx b/src/components/RsvpButton.tsx
index 53302b27..978c18e7 100644
--- a/src/components/RsvpButton.tsx
+++ b/src/components/RsvpButton.tsx
@@ -1,11 +1,11 @@
 'use client';
 
-import { MailCheck, MailOpen } from 'lucide-react';
+import { MailCheck, MailOpen, Clock, Loader2, AlertTriangle } from 'lucide-react';
 import { isLumaUrl } from '@/lib/luma';
 
 interface RsvpButtonProps {
   eventLink: string;
-  status: 'idle' | 'confirmed';
+  status: 'idle' | 'confirmed' | 'pending' | 'submitting' | 'failed';
   onClick: () => void;
 }
 
@@ -24,6 +24,43 @@ export function RsvpButton({ eventLink, status, onClick }: RsvpButtonProps) {
     );
   }
 
+  if (status === 'pending') {
+    return (
+      <div
+        className="p-1 text-yellow-400"
+        title="RSVP pending"
+        aria-label="RSVP pending"
+      >
+        <Clock className="w-4 h-4" />
+      </div>
+    );
+  }
+
+  if (status === 'submitting') {
+    return (
+      <div
+        className="p-1 text-blue-400"
+        title="Submitting RSVP..."
+        aria-label="Submitting RSVP"
+      >
+        <Loader2 className="w-4 h-4 animate-spin" />
+      </div>
+    );
+  }
+
+  if (status === 'failed') {
+    return (
+      <button
+        onClick={(e) => { e.stopPropagation(); e.preventDefault(); onClick(); }}
+        className="p-1 text-red-400 hover:text-red-300 transition-colors cursor-pointer"
+        title="RSVP failed — click to retry"
+        aria-label="RSVP failed, retry"
+      >
+        <AlertTriangle className="w-4 h-4" />
+      </button>
+    );
+  }
+
   return (
     <button
       onClick={(e) => { e.stopPropagation(); e.preventDefault(); onClick(); }}
diff --git a/src/hooks/useBatchRsvp.ts b/src/hooks/useBatchRsvp.ts
new file mode 100644
index 00000000..591af6ec
--- /dev/null
+++ b/src/hooks/useBatchRsvp.ts
@@ -0,0 +1,367 @@
+'use client';
+
+import { useState, useCallback, useRef } from 'react';
+import { useAuth } from '@/contexts/AuthContext';
+import { supabase } from '@/lib/supabase';
+import type { ETHDenverEvent, LumaRegistrationQuestion } from '@/lib/types';
+import type { ScannedFormResult } from '@/lib/luma-form-scanner';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type WizardStep = 'select' | 'profile' | 'custom' | 'review' | 'submitting' | 'results';
+
+export interface BatchProfileData {
+  email: string;
+  firstName: string;
+  lastName: string;
+  company: string;
+  jobTitle: string;
+  phone: string;
+  telegram: string;
+  xHandle: string;
+  linkedin: string;
+  website: string;
+}
+
+export interface ScannedEvent {
+  event: ETHDenverEvent;
+  lumaSlug: string;
+  formResult: ScannedFormResult | null;
+  scanError?: string;
+}
+
+export interface JobStatus {
+  id: number;
+  eventId: string;
+  eventName: string;
+  status: 'pending' | 'submitting' | 'success' | 'failed';
+  errorMessage?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+
+export function useBatchRsvp() {
+  const { user } = useAuth();
+
+  // Wizard state
+  const [step, setStep] = useState<WizardStep>('select');
+  const [selectedEventIds, setSelectedEventIds] = useState<Set<string>>(new Set());
+  const [scannedEvents, setScannedEvents] = useState<Map<string, ScannedEvent>>(new Map());
+  const [scanning, setScanning] = useState(false);
+  const [profileData, setProfileData] = useState<BatchProfileData>({
+    email: '',
+    firstName: '',
+    lastName: '',
+    company: '',
+    jobTitle: '',
+    phone: '',
+    telegram: '',
+    xHandle: '',
+    linkedin: '',
+    website: '',
+  });
+  const [customAnswers, setCustomAnswers] = useState<Map<string, Map<string, string>>>(new Map());
+  const [jobStatuses, setJobStatuses] = useState<JobStatus[]>([]);
+  const pollRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  // ── Event selection ──────────────────────────────────────────────
+
+  const selectEvent = useCallback((eventId: string) => {
+    setSelectedEventIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(eventId)) {
+        next.delete(eventId);
+      } else {
+        next.add(eventId);
+      }
+      return next;
+    });
+  }, []);
+
+  const selectAll = useCallback((eventIds: string[]) => {
+    setSelectedEventIds(new Set(eventIds));
+  }, []);
+
+  const deselectAll = useCallback(() => {
+    setSelectedEventIds(new Set());
+  }, []);
+
+  // ── Profile data ────────────────────────────────────────────────
+
+  const setProfileField = useCallback((field: keyof BatchProfileData, value: string) => {
+    setProfileData((prev) => ({ ...prev, [field]: value }));
+  }, []);
+
+  // ── Custom answers ──────────────────────────────────────────────
+
+  const setAnswer = useCallback((eventId: string, questionId: string, answer: string) => {
+    setCustomAnswers((prev) => {
+      const next = new Map(prev);
+      const eventAnswers = new Map(next.get(eventId) || []);
+      eventAnswers.set(questionId, answer);
+      next.set(eventId, eventAnswers);
+      return next;
+    });
+  }, []);
+
+  // ── Form scanning ──────────────────────────────────────────────
+
+  const scanSelectedEvents = useCallback(async (lumaEvents: ETHDenverEvent[]) => {
+    const slugMap = new Map<string, ETHDenverEvent>();
+    for (const event of lumaEvents) {
+      if (!selectedEventIds.has(event.id)) continue;
+      try {
+        const u = new URL(event.link);
+        const h = u.hostname;
+        if (h === 'lu.ma' || h === 'luma.com' || h === 'www.luma.com') {
+          const slug = u.pathname.split('/').filter(Boolean)[0];
+          if (slug) slugMap.set(slug, event);
+        }
+      } catch {
+        // skip invalid URLs
+      }
+    }
+
+    if (slugMap.size === 0) return;
+
+    setScanning(true);
+    const slugs = Array.from(slugMap.keys());
+
+    try {
+      // Get auth token for the scan request
+      const { data: sessionData } = await supabase.auth.getSession();
+      const token = sessionData?.session?.access_token;
+
+      // Scan in batches of 5
+      for (let i = 0; i < slugs.length; i += 5) {
+        const batch = slugs.slice(i, i + 5);
+        const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+        if (token) headers['Authorization'] = `Bearer ${token}`;
+
+        const res = await fetch('/api/luma/scan-form', {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({ slugs: batch }),
+        });
+
+        if (res.ok) {
+          const { results } = await res.json();
+          setScannedEvents((prev) => {
+            const next = new Map(prev);
+            for (const r of results) {
+              const event = slugMap.get(r.slug);
+              if (event) {
+                next.set(event.id, {
+                  event,
+                  lumaSlug: r.slug,
+                  formResult: r.result || null,
+                  scanError: r.error,
+                });
+              }
+            }
+            return next;
+          });
+        }
+      }
+    } catch (err) {
+      console.error('Scan error:', err);
+    }
+
+    setScanning(false);
+  }, [selectedEventIds]);
+
+  // ── Navigation ──────────────────────────────────────────────────
+
+  const hasCustomFields = useCallback(() => {
+    for (const [eventId] of scannedEvents) {
+      if (!selectedEventIds.has(eventId)) continue;
+      const scanned = scannedEvents.get(eventId);
+      if (scanned?.formResult?.questions && scanned.formResult.questions.length > 0) {
+        return true;
+      }
+    }
+    return false;
+  }, [scannedEvents, selectedEventIds]);
+
+  const nextStep = useCallback(() => {
+    setStep((prev) => {
+      switch (prev) {
+        case 'select': return 'profile';
+        case 'profile': return hasCustomFields() ? 'custom' : 'review';
+        case 'custom': return 'review';
+        case 'review': return 'submitting';
+        default: return prev;
+      }
+    });
+  }, [hasCustomFields]);
+
+  const prevStep = useCallback(() => {
+    setStep((prev) => {
+      switch (prev) {
+        case 'profile': return 'select';
+        case 'custom': return 'profile';
+        case 'review': return hasCustomFields() ? 'custom' : 'profile';
+        case 'results': return 'review';
+        default: return prev;
+      }
+    });
+  }, [hasCustomFields]);
+
+  // ── Submit ──────────────────────────────────────────────────────
+
+  const submit = useCallback(async () => {
+    if (!user) return;
+
+    setStep('submitting');
+
+    const events = Array.from(selectedEventIds)
+      .map((eventId) => {
+        const scanned = scannedEvents.get(eventId);
+        if (!scanned) return null;
+        // Skip events that failed scanning (no eventApiId means we can't submit)
+        if (!scanned.formResult?.eventApiId) return null;
+        const eventAnswers = customAnswers.get(eventId);
+        return {
+          eventId,
+          lumaSlug: scanned.lumaSlug,
+          eventName: scanned.event.name,
+          eventApiId: scanned.formResult.eventApiId,
+          customAnswers: eventAnswers ? Object.fromEntries(eventAnswers) : undefined,
+        };
+      })
+      .filter(Boolean);
+
+    if (events.length === 0) {
+      setStep('review');
+      return;
+    }
+
+    try {
+      const { data: sessionData } = await supabase.auth.getSession();
+      const token = sessionData?.session?.access_token;
+      if (!token) {
+        setStep('review');
+        return;
+      }
+
+      const res = await fetch('/api/batch-rsvp', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+          events,
+          profile: profileData,
+        }),
+      });
+
+      if (res.ok) {
+        const { jobs } = await res.json();
+        const statuses: JobStatus[] = jobs.map((j: { id: number; event_id: string; event_name: string; status: string }) => ({
+          id: j.id,
+          eventId: j.event_id,
+          eventName: j.event_name || '',
+          status: j.status as JobStatus['status'],
+        }));
+
+        setJobStatuses(statuses);
+        setStep('results');
+
+        // Start polling for status updates
+        startPolling(statuses.map((s) => s.id), token);
+      } else {
+        console.error('Batch RSVP submit failed');
+        setStep('review');
+      }
+    } catch (err) {
+      console.error('Submit error:', err);
+      setStep('review');
+    }
+  }, [user, selectedEventIds, scannedEvents, customAnswers, profileData]);
+
+  // ── Polling ─────────────────────────────────────────────────────
+
+  const startPolling = useCallback((jobIds: number[], token: string) => {
+    if (pollRef.current) clearInterval(pollRef.current);
+
+    pollRef.current = setInterval(async () => {
+      try {
+        const res = await fetch(`/api/batch-rsvp?ids=${jobIds.join(',')}`, {
+          headers: { 'Authorization': `Bearer ${token}` },
+        });
+
+        if (res.ok) {
+          const { jobs } = await res.json();
+          setJobStatuses(
+            jobs.map((j: { id: number; event_id: string; event_name: string; status: string; error_message?: string }) => ({
+              id: j.id,
+              eventId: j.event_id,
+              eventName: j.event_name || '',
+              status: j.status as JobStatus['status'],
+              errorMessage: j.error_message,
+            }))
+          );
+
+          // Stop polling if all jobs are terminal
+          const allDone = jobs.every(
+            (j: { status: string }) => j.status === 'success' || j.status === 'failed'
+          );
+          if (allDone && pollRef.current) {
+            clearInterval(pollRef.current);
+            pollRef.current = null;
+          }
+        }
+      } catch {
+        // Silently retry on next interval
+      }
+    }, 3000);
+  }, []);
+
+  const stopPolling = useCallback(() => {
+    if (pollRef.current) {
+      clearInterval(pollRef.current);
+      pollRef.current = null;
+    }
+  }, []);
+
+  // ── Reset ───────────────────────────────────────────────────────
+
+  const reset = useCallback(() => {
+    stopPolling();
+    setStep('select');
+    setSelectedEventIds(new Set());
+    setScannedEvents(new Map());
+    setCustomAnswers(new Map());
+    setJobStatuses([]);
+    setScanning(false);
+  }, [stopPolling]);
+
+  return {
+    // State
+    step,
+    selectedEventIds,
+    scannedEvents,
+    scanning,
+    profileData,
+    customAnswers,
+    jobStatuses,
+
+    // Actions
+    selectEvent,
+    selectAll,
+    deselectAll,
+    setProfileField,
+    setAnswer,
+    scanSelectedEvents,
+    nextStep,
+    prevStep,
+    submit,
+    reset,
+    stopPolling,
+  };
+}
diff --git a/src/hooks/useProfile.ts b/src/hooks/useProfile.ts
index 5e328fc5..bf81e35c 100644
--- a/src/hooks/useProfile.ts
+++ b/src/hooks/useProfile.ts
@@ -91,7 +91,7 @@ export function useProfile() {
       try {
         const { data, error } = await supabase
           .from('profiles')
-          .select('user_id, email, display_name, x_handle, rsvp_name, avatar_url, telegram_handle, company, linkedin_url, job_title')
+          .select('user_id, email, display_name, x_handle, rsvp_name, avatar_url, telegram_handle, company, linkedin_url, job_title, phone, website, first_name, last_name')
           .eq('user_id', user!.id)
           .maybeSingle();
 
@@ -116,6 +116,10 @@ export function useProfile() {
             company: null,
             linkedin_url: null,
             job_title: null,
+            phone: null,
+            website: null,
+            first_name: null,
+            last_name: null,
           };
 
           const { error: insertError } = await supabase
@@ -126,7 +130,7 @@ export function useProfile() {
             // Could be a race condition — try fetching again
             const { data: retryData } = await supabase
               .from('profiles')
-              .select('user_id, email, display_name, x_handle, rsvp_name, avatar_url, telegram_handle, company, linkedin_url, job_title')
+              .select('user_id, email, display_name, x_handle, rsvp_name, avatar_url, telegram_handle, company, linkedin_url, job_title, phone, website, first_name, last_name')
               .eq('user_id', user!.id)
               .maybeSingle();
 
@@ -150,7 +154,7 @@ export function useProfile() {
   }, [user, authLoading]);
 
   const updateProfile = useCallback(
-    async (fields: Partial<Pick<UserProfile, 'display_name' | 'x_handle' | 'rsvp_name' | 'telegram_handle' | 'company' | 'linkedin_url' | 'job_title'>>) => {
+    async (fields: Partial<Pick<UserProfile, 'display_name' | 'x_handle' | 'rsvp_name' | 'telegram_handle' | 'company' | 'linkedin_url' | 'job_title' | 'phone' | 'website' | 'first_name' | 'last_name'>>) => {
       if (!user) return;
 
       const { error } = await supabase
diff --git a/src/hooks/useRsvp.ts b/src/hooks/useRsvp.ts
index 6a936f62..8561c36d 100644
--- a/src/hooks/useRsvp.ts
+++ b/src/hooks/useRsvp.ts
@@ -48,5 +48,5 @@ export function useRsvp() {
 
   const closeRsvp = useCallback(() => setActiveRsvp(null), []);
 
-  return { getRsvpStatus, openRsvp, confirmRsvp, closeRsvp, activeRsvp };
+  return { getRsvpStatus, openRsvp, confirmRsvp, closeRsvp, activeRsvp, confirmedIds };
 }
diff --git a/src/lib/api-validation.ts b/src/lib/api-validation.ts
index b27b748b..2640685f 100644
--- a/src/lib/api-validation.ts
+++ b/src/lib/api-validation.ts
@@ -118,6 +118,34 @@ export const ABTrackEventSchema = z.object({
   metadata: z.record(z.string(), z.unknown()).optional(),
 });
 
+/** Schema for POST /api/luma/scan-form */
+export const ScanFormFieldsSchema = z.object({
+  slugs: z.array(z.string().min(1)).min(1).max(5),
+});
+
+/** Schema for POST /api/batch-rsvp */
+export const BatchRsvpSubmitSchema = z.object({
+  events: z.array(z.object({
+    eventId: z.string().min(1),
+    lumaSlug: z.string().min(1),
+    eventName: z.string(),
+    eventApiId: z.string().min(1),
+    customAnswers: z.record(z.string(), z.string()).optional(),
+  })).min(1).max(20),
+  profile: z.object({
+    email: z.string().email(),
+    firstName: z.string().min(1),
+    lastName: z.string().min(1),
+    company: z.string().optional(),
+    jobTitle: z.string().optional(),
+    phone: z.string().optional(),
+    telegram: z.string().optional(),
+    xHandle: z.string().optional(),
+    linkedin: z.string().optional(),
+    website: z.string().optional(),
+  }),
+});
+
 /** Schema for POST /api/admin/submissions */
 export const SubmissionActionSchema = z.object({
   password: z.string(),
diff --git a/src/lib/luma-form-scanner.ts b/src/lib/luma-form-scanner.ts
new file mode 100644
index 00000000..be0ebb5e
--- /dev/null
+++ b/src/lib/luma-form-scanner.ts
@@ -0,0 +1,128 @@
+/**
+ * Luma form field scanner — fetches registration questions for a Luma event.
+ *
+ * Uses the public Luma API: GET https://api.lu.ma/url?url={slug}
+ * Returns the event's registration_questions[], event api_id, and name_requirement.
+ */
+
+import type { LumaRegistrationQuestion } from './types';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const USER_AGENT = 'Mozilla/5.0 (compatible; SheetsEventBot/1.0; +https://sheeets.com)';
+const FETCH_TIMEOUT_MS = 8000;
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ScannedFormResult {
+  eventApiId: string;
+  eventName: string;
+  nameRequirement: string | null;     // 'full-name' | 'first-last'
+  questions: LumaRegistrationQuestion[];
+}
+
+// ---------------------------------------------------------------------------
+// Scan form fields for a Luma event slug
+// ---------------------------------------------------------------------------
+
+export async function scanLumaFormFields(slug: string): Promise<ScannedFormResult> {
+  const res = await fetch(`https://api.lu.ma/url?url=${encodeURIComponent(slug)}`, {
+    headers: { 'User-Agent': USER_AGENT },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+  });
+
+  if (!res.ok) {
+    throw new Error(`Luma API returned HTTP ${res.status} for slug "${slug}"`);
+  }
+
+  const data = await res.json();
+
+  if (data.kind !== 'event' || !data.data?.event) {
+    throw new Error(`Slug "${slug}" does not point to a Luma event`);
+  }
+
+  const event = data.data.event;
+  const eventApiId: string = event.api_id || '';
+  const eventName: string = event.name || slug;
+  const nameRequirement: string | null = data.data.name_requirement || null;
+
+  // Parse registration_questions from the API response
+  const rawQuestions: unknown[] = data.data.registration_questions || [];
+  const questions: LumaRegistrationQuestion[] = rawQuestions
+    .filter((q): q is Record<string, unknown> => q !== null && typeof q === 'object')
+    .map((q) => ({
+      id: String(q.id || ''),
+      label: String(q.label || q.question || ''),
+      question_type: mapQuestionType(String(q.type || q.question_type || 'text')),
+      is_required: Boolean(q.is_required ?? q.required ?? false),
+      options: Array.isArray(q.options) ? q.options.map(String) : undefined,
+      terms_content: q.terms_content ? String(q.terms_content) : undefined,
+      job_title_label: q.job_title_label ? String(q.job_title_label) : undefined,
+    }));
+
+  return { eventApiId, eventName, nameRequirement, questions };
+}
+
+// ---------------------------------------------------------------------------
+// Map Luma question type strings to our normalized set
+// ---------------------------------------------------------------------------
+
+function mapQuestionType(raw: string): LumaRegistrationQuestion['question_type'] {
+  const normalized = raw.toLowerCase().replace(/[-_\s]/g, '');
+  switch (normalized) {
+    case 'company':
+      return 'company';
+    case 'linkedin':
+      return 'linkedin';
+    case 'twitter':
+    case 'x':
+      return 'twitter';
+    case 'dropdown':
+    case 'select':
+      return 'dropdown';
+    case 'multiselect':
+    case 'multi_select':
+    case 'checkbox':
+      return 'multi-select';
+    case 'terms':
+    case 'tos':
+      return 'terms';
+    default:
+      return 'text';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Map a question to a profile field name for auto-fill
+// ---------------------------------------------------------------------------
+
+export function mapQuestionToProfileField(
+  q: LumaRegistrationQuestion
+): string | null {
+  const label = q.label.toLowerCase();
+
+  // Type-based mapping first
+  switch (q.question_type) {
+    case 'company':
+      return 'company';
+    case 'linkedin':
+      return 'linkedin_url';
+    case 'twitter':
+      return 'x_handle';
+  }
+
+  // Label-based mapping
+  if (/company|organization|org\b/i.test(label)) return 'company';
+  if (/job\s*title|role|position/i.test(label)) return 'job_title';
+  if (/linkedin/i.test(label)) return 'linkedin_url';
+  if (/twitter|x\s*handle|x\.com/i.test(label)) return 'x_handle';
+  if (/telegram/i.test(label)) return 'telegram_handle';
+  if (/phone|mobile|cell/i.test(label)) return 'phone';
+  if (/website|url|homepage/i.test(label)) return 'website';
+
+  return null;
+}
diff --git a/src/lib/luma-registration.ts b/src/lib/luma-registration.ts
new file mode 100644
index 00000000..6dfd6f3f
--- /dev/null
+++ b/src/lib/luma-registration.ts
@@ -0,0 +1,94 @@
+/**
+ * Luma registration submission — posts to the Luma event/register endpoint.
+ *
+ * Requires a Cloudflare Turnstile token header (x-luma-turnstile-token).
+ * Without a valid token, the Luma API returns auth/additional-verification-required.
+ */
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface RegistrationAnswer {
+  question_id: string;
+  value: string | string[] | boolean | { company: string | null; job_title: string | null } | null;
+  label: string;
+  question_type: string;
+}
+
+export interface RegistrationPayload {
+  name: string;
+  first_name: string;
+  last_name: string;
+  email: string;
+  event_api_id: string;
+  registration_answers: RegistrationAnswer[];
+  phone_number?: string;
+  turnstile_token: string;
+}
+
+export interface RegistrationResult {
+  success: boolean;
+  error?: string;
+  code?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  data?: any;
+}
+
+// ---------------------------------------------------------------------------
+// Submit a registration to Luma
+// ---------------------------------------------------------------------------
+
+export async function submitLumaRegistration(
+  payload: RegistrationPayload
+): Promise<RegistrationResult> {
+  try {
+    const body = {
+      name: payload.name,
+      first_name: payload.first_name,
+      last_name: payload.last_name,
+      email: payload.email,
+      event_api_id: payload.event_api_id,
+      registration_answers: payload.registration_answers,
+      phone_number: payload.phone_number || null,
+      for_waitlist: false,
+      expected_amount_cents: 0,
+      expected_amount_tax: 0,
+      currency: 'usd',
+      opened_from: 'embed',
+      payment_method: null,
+      payment_currency: null,
+      coupon_code: null,
+      token_gate_info: null,
+      eth_address_info: null,
+      solana_address_info: null,
+      ticket_type_to_selection: {},
+    };
+
+    const res = await fetch('https://api.lu.ma/event/register', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-luma-turnstile-token': payload.turnstile_token,
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15000),
+    });
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      return {
+        success: false,
+        error: data.message || data.error || `HTTP ${res.status}`,
+        code: data.code || undefined,
+        data,
+      };
+    }
+
+    return { success: true, data };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, error: message };
+  }
+}
diff --git a/src/lib/types.ts b/src/lib/types.ts
index fe8da153..084aa3c5 100644
--- a/src/lib/types.ts
+++ b/src/lib/types.ts
@@ -65,6 +65,10 @@ export interface UserProfile {
   company: string | null;
   linkedin_url: string | null;
   job_title: string | null;
+  phone: string | null;
+  website: string | null;
+  first_name: string | null;
+  last_name: string | null;
 }
 
 export interface Friend {
@@ -360,3 +364,53 @@ export interface Submission {
   sheet_row: number | null;
   created_at: string;
 }
+
+/* ------------------------------------------------------------------ */
+/* Batch RSVP (Luma form scanning + registration)                      */
+/* ------------------------------------------------------------------ */
+
+export interface LumaRegistrationQuestion {
+  id: string;
+  label: string;
+  question_type: 'company' | 'text' | 'linkedin' | 'twitter' | 'dropdown' | 'multi-select' | 'terms';
+  is_required: boolean;
+  options?: string[];           // for dropdown / multi-select
+  terms_content?: string;       // for terms type
+  job_title_label?: string;     // for company type
+}
+
+export interface LumaFormField {
+  id: number;
+  luma_slug: string;
+  event_api_id: string;
+  event_name: string | null;
+  name_requirement: string | null;
+  questions: LumaRegistrationQuestion[];
+  scanned_at: string;
+}
+
+export type BatchRsvpJobStatus = 'pending' | 'submitting' | 'success' | 'failed';
+
+export interface BatchRsvpJob {
+  id: number;
+  user_id: string;
+  event_id: string;
+  luma_slug: string;
+  event_name: string | null;
+  event_api_id: string;
+  status: BatchRsvpJobStatus;
+  error_message: string | null;
+  profile_snapshot: Record<string, string>;
+  custom_answers: Record<string, string>;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface CustomFieldAnswer {
+  id: number;
+  user_id: string;
+  question_label: string;
+  question_type: string;
+  answer: string;
+  updated_at: string;
+}
diff --git a/supabase/migrations/20260504140000_batch_rsvp_profile.sql b/supabase/migrations/20260504140000_batch_rsvp_profile.sql
new file mode 100644
index 00000000..40632dff
--- /dev/null
+++ b/supabase/migrations/20260504140000_batch_rsvp_profile.sql
@@ -0,0 +1,5 @@
+-- Add extra profile fields for batch RSVP form pre-fill
+ALTER TABLE profiles ADD COLUMN IF NOT EXISTS phone text;
+ALTER TABLE profiles ADD COLUMN IF NOT EXISTS website text;
+ALTER TABLE profiles ADD COLUMN IF NOT EXISTS first_name text;
+ALTER TABLE profiles ADD COLUMN IF NOT EXISTS last_name text;
diff --git a/supabase/migrations/20260504150000_batch_rsvp_tables.sql b/supabase/migrations/20260504150000_batch_rsvp_tables.sql
new file mode 100644
index 00000000..5cd17c17
--- /dev/null
+++ b/supabase/migrations/20260504150000_batch_rsvp_tables.sql
@@ -0,0 +1,88 @@
+-- ================================================================
+-- Luma form fields cache
+-- Stores the registration questions for each Luma event so we
+-- don't have to re-scan every time.
+-- ================================================================
+
+CREATE TABLE IF NOT EXISTS luma_form_fields (
+  id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  luma_slug text NOT NULL,
+  event_api_id text NOT NULL,
+  event_name text,
+  name_requirement text,           -- 'full-name' | 'first-last'
+  questions jsonb NOT NULL DEFAULT '[]'::jsonb,
+  scanned_at timestamptz NOT NULL DEFAULT now(),
+  UNIQUE (luma_slug)
+);
+
+ALTER TABLE luma_form_fields ENABLE ROW LEVEL SECURITY;
+
+-- Anyone can read cached form fields
+CREATE POLICY "luma_form_fields_select" ON luma_form_fields
+  FOR SELECT USING (true);
+
+-- Only service role can insert/update (via API route or CLI script)
+CREATE POLICY "luma_form_fields_insert" ON luma_form_fields
+  FOR INSERT WITH CHECK (false);
+CREATE POLICY "luma_form_fields_update" ON luma_form_fields
+  FOR UPDATE USING (false);
+
+-- ================================================================
+-- Custom field answers cache
+-- Remembers user answers to custom Luma questions so they can
+-- be pre-filled across events.
+-- ================================================================
+
+CREATE TABLE IF NOT EXISTS custom_field_answers (
+  id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  user_id uuid NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  question_label text NOT NULL,
+  question_type text NOT NULL,     -- 'text' | 'dropdown' | 'multi-select' | 'terms'
+  answer text NOT NULL DEFAULT '',
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  UNIQUE (user_id, question_label)
+);
+
+ALTER TABLE custom_field_answers ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY "custom_field_answers_select" ON custom_field_answers
+  FOR SELECT USING (auth.uid() = user_id);
+CREATE POLICY "custom_field_answers_insert" ON custom_field_answers
+  FOR INSERT WITH CHECK (auth.uid() = user_id);
+CREATE POLICY "custom_field_answers_update" ON custom_field_answers
+  FOR UPDATE USING (auth.uid() = user_id);
+CREATE POLICY "custom_field_answers_delete" ON custom_field_answers
+  FOR DELETE USING (auth.uid() = user_id);
+
+-- ================================================================
+-- Batch RSVP jobs
+-- Tracks each individual registration submission within a batch.
+-- ================================================================
+
+CREATE TABLE IF NOT EXISTS batch_rsvp_jobs (
+  id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  user_id uuid NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  event_id text NOT NULL,
+  luma_slug text NOT NULL,
+  event_name text,
+  event_api_id text NOT NULL,
+  status text NOT NULL DEFAULT 'pending'
+    CHECK (status IN ('pending', 'submitting', 'success', 'failed')),
+  error_message text,
+  profile_snapshot jsonb NOT NULL DEFAULT '{}'::jsonb,
+  custom_answers jsonb NOT NULL DEFAULT '{}'::jsonb,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+ALTER TABLE batch_rsvp_jobs ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY "batch_rsvp_jobs_select" ON batch_rsvp_jobs
+  FOR SELECT USING (auth.uid() = user_id);
+CREATE POLICY "batch_rsvp_jobs_insert" ON batch_rsvp_jobs
+  FOR INSERT WITH CHECK (auth.uid() = user_id);
+CREATE POLICY "batch_rsvp_jobs_update" ON batch_rsvp_jobs
+  FOR UPDATE USING (auth.uid() = user_id);
+
+CREATE INDEX IF NOT EXISTS idx_batch_rsvp_jobs_user ON batch_rsvp_jobs (user_id);
+CREATE INDEX IF NOT EXISTS idx_batch_rsvp_jobs_status ON batch_rsvp_jobs (status);