How to Integrate Lovable with Oracle Eloqua

To use the Eloqua API, you need three pieces of information: your Eloqua Company Name (the organization identifier used when logging in — not the full company name, but the short code used as part of your login credentials), your API username, and your password. In Eloqua, your login username format is typically CompanyName\\Username — the Company Name is the part before the backslash. You can find it on the Eloqua login page or in your account settings. For Basic Auth, you will encode these as a Base64 string with the format 'CompanyName\\Username:Password'. For OAuth2 (more secure for production), you need to create an Eloqua application in Eloqua's API Console and obtain a Client ID and Client Secret. For this tutorial, we will use Basic Auth for simplicity — the same Edge Function pattern applies to OAuth2 by replacing the Authorization header. The critical insight about Eloqua's architecture is that your API URL is NOT fixed. Every Eloqua instance has a unique Pod URL. You MUST call https://login.eloqua.com/id with your Basic Auth credentials first — this returns a JSON object containing your instance's Pod URL in the urls.base field.

In your Lovable project, open the Cloud tab by clicking the plus (+) icon next to the preview panel. Navigate to the Secrets section and add three secrets: ELOQUA_COMPANY (your Eloqua company name — the short identifier used in login, before the backslash), ELOQUA_USERNAME (your API username, without the company prefix), and ELOQUA_PASSWORD (your Eloqua password). The Edge Function will combine these as 'CompanyName\\Username:Password', Base64-encode this string, and use it as a Basic Auth header. Click Save after each entry. If you are using Eloqua OAuth2 instead of Basic Auth, add ELOQUA_CLIENT_ID and ELOQUA_CLIENT_SECRET instead. The Pod URL itself will be discovered and cached at runtime — you do not need to store it as a secret since it is not sensitive and can be re-fetched from login.eloqua.com.

Build the Edge Function that implements the two-step Eloqua connection pattern. The function first checks if a cached Pod URL exists in Supabase. If not, it calls https://login.eloqua.com/id with Basic Auth to discover the Pod URL and caches it (Pod URLs are stable — they rarely change, so a 24-hour or even weekly cache is appropriate). With the Pod URL established, the function accepts proxy requests and forwards them to the correct Eloqua API endpoint at the Pod URL. Eloqua's REST API paths follow the pattern /api/REST/2.0/ for most operations. The function accepts method (GET/POST/PUT/DELETE), endpoint (the path under /api/REST/2.0/), and an optional body. Create a table called eloqua_config in Supabase to store the pod URL with a last_updated timestamp.

1import { serve } from 'https://deno.land/std@0.168.0/http/server.ts'
2import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'
3
4const corsHeaders = {
5  'Access-Control-Allow-Origin': '*',
6  'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
7}
8
9async function getEloquaPodUrl(authHeader: string, supabase: any): Promise<string> {
10  // Check cache first (valid for 7 days — pod URLs rarely change)
11  const { data: cached } = await supabase
12    .from('eloqua_config')
13    .select('pod_url, updated_at')
14    .eq('key', 'pod_url')
15    .gt('updated_at', new Date(Date.now() - 7 * 24 * 3600000).toISOString())
16    .single()
17
18  if (cached?.pod_url) return cached.pod_url
19
20  // Discover pod URL
21  const resp = await fetch('https://login.eloqua.com/id', {
22    headers: { 'Authorization': authHeader, 'Accept': 'application/json' },
23  })
24
25  if (!resp.ok) throw new Error(`Eloqua login discovery failed: ${resp.status}`)
26
27  const data = await resp.json()
28  const podUrl = data.urls?.base
29  if (!podUrl) throw new Error('Could not determine Eloqua Pod URL from login response')
30
31  // Cache pod URL
32  await supabase.from('eloqua_config').upsert({
33    key: 'pod_url',
34    pod_url: podUrl,
35    updated_at: new Date().toISOString(),
36  }, { onConflict: 'key' })
37
38  return podUrl
39}
40
41serve(async (req) => {
42  if (req.method === 'OPTIONS') return new Response('ok', { headers: corsHeaders })
43
44  try {
45    const supabase = createClient(Deno.env.get('SUPABASE_URL')!, Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!)
46
47    const company = Deno.env.get('ELOQUA_COMPANY')
48    const username = Deno.env.get('ELOQUA_USERNAME')
49    const password = Deno.env.get('ELOQUA_PASSWORD')
50
51    if (!company || !username || !password) throw new Error('Eloqua credentials not configured')
52
53    const credentials = btoa(`${company}\\${username}:${password}`)
54    const authHeader = `Basic ${credentials}`
55
56    const podUrl = await getEloquaPodUrl(authHeader, supabase)
57
58    const { method, endpoint, body: requestBody } = await req.json()
59
60    const apiUrl = `${podUrl}/api/REST/2.0${endpoint.startsWith('/') ? endpoint : '/' + endpoint}`
61
62    const response = await fetch(apiUrl, {
63      method: method || 'GET',
64      headers: {
65        'Authorization': authHeader,
66        'Content-Type': 'application/json',
67        'Accept': 'application/json',
68      },
69      body: requestBody ? JSON.stringify(requestBody) : undefined,
70    })
71
72    const responseData = await response.json()
73    return new Response(JSON.stringify(responseData),
74      { headers: { ...corsHeaders, 'Content-Type': 'application/json' } })
75  } catch (error) {
76    return new Response(JSON.stringify({ error: error.message }),
77      { status: 500, headers: { ...corsHeaders, 'Content-Type': 'application/json' } })
78  }
79})

Wire up contact creation so that when a user submits a form in your Lovable app, their data is sent to Eloqua via the Edge Function. Eloqua's contact creation endpoint is POST /contacts. The request body uses Eloqua's field name format, which uses fieldDef IDs for custom fields but has named fields for standard attributes like firstName, lastName, emailAddress, company, and title. Creating a contact uses fieldValues format: an array of {id, value} objects for custom fields, plus top-level named fields for standard attributes. Create a form submit handler that constructs the Eloqua contact payload and calls the eloqua-proxy Edge Function. Handle the case where a contact already exists (Eloqua returns an error for duplicate email addresses — use a search-or-create pattern).

1// Eloqua contact creation payload
2const eloquaContact = {
3  firstName: formData.firstName,
4  lastName: formData.lastName,
5  emailAddress: formData.email,
6  company: formData.company,
7  title: formData.jobTitle,
8  // Custom fields use fieldValues array with Eloqua field definition IDs
9  // fieldValues: [{ id: '100001', value: 'your custom value' }]
10}
11
12// Call via Edge Function
13const { data, error } = await supabase.functions.invoke('eloqua-proxy', {
14  body: {
15    method: 'POST',
16    endpoint: '/contacts',
17    body: eloquaContact,
18  },
19})