ZoomInfo

Before writing any FlutterFlow code, it is important to understand why this integration requires a server-side proxy and what ZoomInfo's authentication actually involves — this will save you from a frustrating debugging loop later. ZoomInfo's API authentication is a JWT-based PKI flow. Your ZoomInfo account comes with three credentials: a username (your ZoomInfo login email), a client ID (a string identifier for your API app), and a private key (a cryptographic secret). To make API calls, you: 1. Combine the username and client ID to create a payload. 2. Sign the payload with the private key to produce a JWT. 3. Send the JWT to ZoomInfo's auth endpoint to receive a short-lived Bearer access token. 4. Use the Bearer token in the Authorization header of Enrich/Search API calls. Verify the exact format of the JWT payload and signing algorithm with your ZoomInfo account representative — the specifics can differ between contract tiers. The private key step is the critical security constraint: if you put the private key in Dart code, it ships inside the compiled Flutter app binary. Anyone who downloads your app and uses standard reverse-engineering tools can extract the private key and use it to call ZoomInfo's API as you — consuming your per-record credit balance and exposing your enterprise data contract. The correct architecture: the private key never leaves your Firebase Cloud Function. FlutterFlow sends only a domain or email to your function; the function does the JWT generation and Enrich call; the function returns only the enriched data. ZoomInfo never sees a direct call from the FlutterFlow app.

Create a Firebase Cloud Function in your Firebase project (Blaze plan required for outbound HTTP). This function is responsible for: 1. Reading the ZoomInfo credentials from Firebase environment config — never from source code. 2. Generating a JWT using the private key (using the jsonwebtoken npm package). 3. Exchanging the JWT for a short-lived Bearer access token at ZoomInfo's token endpoint. 4. Calling the ZoomInfo Enrich API at api.zoominfo.com with the Bearer token and the domain or email passed by FlutterFlow. 5. Returning the enriched company and contact data as JSON. Before deploying, set environment config: firebase functions:config:set zoominfo.username="your@email.com" zoominfo.client_id="YOUR_CLIENT_ID" zoominfo.private_key="YOUR_PRIVATE_KEY" The private_key value should be the PEM-formatted key string with newlines escaped. Deploy with firebase deploy --only functions. The Cloud Function also handles caching of the access token in memory to avoid re-generating the JWT on every enrichment call, since JWT generation is computationally more expensive than a cached Bearer token lookup. IMPORTANT: ZoomInfo bills per record enriched. Add logic in the function to validate that the input (domain or email) is non-empty and well-formed before calling the Enrich API — reject invalid inputs at the function level rather than burning a credit on a malformed request.

1const functions = require('firebase-functions');
2const axios = require('axios');
3const jwt = require('jsonwebtoken');
4
5let cachedToken = null;
6let tokenExpiry = 0;
7
8async function getZoomInfoToken(cfg) {
9  if (cachedToken && Date.now() < tokenExpiry) return cachedToken;
10  // Step 1: generate JWT from credentials
11  // Verify exact payload claims with your ZoomInfo account rep
12  const payload = {
13    iss: cfg.client_id,
14    sub: cfg.username
15  };
16  const signedJwt = jwt.sign(payload, cfg.private_key, {
17    algorithm: 'RS256',
18    expiresIn: '60s'
19  });
20  // Step 2: exchange JWT for Bearer access token
21  // Verify the exact token endpoint URL for your ZoomInfo plan
22  const res = await axios.post(
23    'https://api.zoominfo.com/authenticate',
24    { jwt: signedJwt },
25    { headers: { 'Content-Type': 'application/json' } }
26  );
27  cachedToken = res.data.jwt; // verify response field name with your plan
28  tokenExpiry = Date.now() + 55 * 60 * 1000; // cache ~55 minutes
29  return cachedToken;
30}
31
32exports.enrichLead = functions.https.onRequest(async (req, res) => {
33  res.setHeader('Access-Control-Allow-Origin', '*');
34  if (req.method === 'OPTIONS') return res.status(204).send('');
35  const cfg = functions.config().zoominfo;
36  const { domain, email } = req.body;
37  if (!domain && !email) {
38    return res.status(400).json({ error: 'Provide domain or email' });
39  }
40  try {
41    const token = await getZoomInfoToken(cfg);
42    // Verify endpoint path and request body structure for your plan
43    const body = domain
44      ? { companyMatchKeys: [{ websiteURL: domain }], outputFields: ['id', 'name', 'industry', 'employeeCount', 'revenueRange'] }
45      : { personMatchKeys: [{ emailAddress: email }], outputFields: ['firstName', 'lastName', 'jobTitle', 'companyName', 'linkedInURL'] };
46    const endpoint = domain
47      ? 'https://api.zoominfo.com/enrich/company'
48      : 'https://api.zoominfo.com/enrich/contact';
49    const result = await axios.post(endpoint, body, {
50      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' }
51    });
52    res.json(result.data);
53  } catch (err) {
54    const status = err.response ? err.response.status : 500;
55    res.status(status).json({ error: err.message });
56  }
57});

With the Cloud Function deployed and tested, configure FlutterFlow to call it. In FlutterFlow, click API Calls in the left navigation panel. Click + Add and choose Create API Group. Name it ZoomInfo and set the Base URL to your Firebase Cloud Function's HTTPS trigger URL (e.g. https://us-central1-your-project.cloudfunctions.net). Inside the ZoomInfo group, click Add API Call and name it EnrichLead. Set the Method to POST and the Endpoint to /enrichLead (or your function's route). You do not need to add an Authorization header — your Cloud Function handles all ZoomInfo authentication internally. Under the Variables tab, add two variables: domain (String, optional) and email (String, optional). In the Body tab, select JSON and set: ```json { "domain": "{{ domain }}", "email": "{{ email }}" } ``` Under the Response & Test tab, paste a sample response JSON from your Cloud Function test — for a company enrichment, this might include fields like name, industry, employeeCount, and revenueRange. Click Generate JSON Paths to create bindings like $.data[0].name, $.data[0].industry, and $.data[0].employeeCount. Verify the exact JSON path structure by running a real call through the Test tab (using a test domain like 'example.com') and examining the actual response shape from your Cloud Function. The structure will match your ZoomInfo plan's response format. Save the API Call.

1{
2  "method": "POST",
3  "endpoint": "/enrichLead",
4  "headers": { "Content-Type": "application/json" },
5  "body": {
6    "domain": "{{ domain }}",
7    "email": "{{ email }}"
8  }
9}

Now connect the EnrichLead API Call to your lead capture form in FlutterFlow. On your lead form screen, add a TextField for the company domain (or email) and an 'Enrich' Button. The critical design decision here is to wire the enrichment call to the button tap — not to the TextField's onChange event. Triggering enrichment on every keystroke would call the Cloud Function dozens of times as the user types, burning through ZoomInfo's per-record credit cap extremely quickly. The Enrich button is the correct trigger. Create a page variable called isEnriching (Boolean, initial value false) and another called enrichError (String, initial value ''). In the Action Flow Editor on the Enrich button: 1. First action: Update Page State → set isEnriching to true, clear enrichError. 2. Second action: Backend/API Calls → ZoomInfo → EnrichLead. Map the domain variable to the TextField's value. 3. On success branch: extract the JSON Path values from the action output and use Update Page State to set individual page variables (companyName, industry, headcount, revenueRange). Then set isEnriching to false. 4. On failure branch: set enrichError to a human-readable message and set isEnriching to false. Disable the Enrich button when isEnriching is true (via a Conditional Widget property on the button's disabled state). Show a CircularProgressIndicator when isEnriching is true. Show the enrichError text in a red Text widget, conditionally visible when enrichError is not empty. Bind the auto-filled output fields (Company Name, Industry, Headcount) to their respective page variables. After enrichment succeeds, these fields populate automatically without user input.

ZoomInfo's per-record billing model makes error handling and call discipline more important here than in most integrations. A few implementation details that protect your credit cap and improve user experience: Validate input before calling: In the Action Flow Editor, add a Conditional action before the EnrichLead call. Check that the domain TextField is not empty and contains at least one period (basic domain format check). If validation fails, show a validation message — no credit is consumed. Similarly, validate email format before email-based enrichment. Handle no-match gracefully: ZoomInfo returns a 200 response with an empty data array when no match is found for the input. Parse the array length from the JSON Path response. If the array is empty, show a 'No ZoomInfo data found for this domain' message rather than leaving all fields blank with no explanation. Handle credit exhaustion: ZoomInfo returns an error when the account's credit cap is reached (verify the exact HTTP status and error code with your account rep — it may be 402 or a specific error message in the response body). Catch this in the failure branch of the Action Flow Editor and show a meaningful message like 'Enrichment is temporarily unavailable — contact your admin.' For production apps, consider logging each enrichment call (domain queried, timestamp, whether a match was found) to Firestore so you can audit credit usage and identify if any screen is triggering unexpected enrichment calls. If you need help setting up this credit-tracking pattern alongside the FlutterFlow UI, RapidDev's team builds integrations like this every week — free scoping call at rapidevelopers.com/contact.