RocketReach

Log in to your RocketReach account at rocketreach.co and navigate to your Account Settings. Look for the 'API' or 'Integrations' section — your Api-Key is displayed there as a long alphanumeric string. Copy it and store it securely (a password manager, not a sticky note or a chat message). Before building, spend two minutes understanding the billing model so you don't run out of credits mid-development. Every person lookup that returns contact data consumes one or more credits depending on your plan. Lookups that return no results (person not found) typically do not charge credits, but check your plan's terms. Company lookups (`/company/lookup`) are often a separate entitlement — if your account does not have the company-lookup add-on, calls to that endpoint return an access error. Check your plan at rocketreach.co/pricing or contact RocketReach support to confirm what your subscription includes. Also understand the async status field: when you call `/person/lookup`, RocketReach may return immediately with `status: 'complete'` and a full `emails` array, or it may return `status: 'progress'` with an empty `emails` array while it processes the lookup in the background. Your app needs to handle both cases — polling with a delay when status is 'progress,' or simply informing the user that the result is being prepared. We will handle this in the Cloud Function so FlutterFlow always receives a final result.

The Cloud Function is the security layer between your FlutterFlow app and RocketReach. It stores your Api-Key in Firebase environment configuration (never in code), receives lookup requests from FlutterFlow, calls RocketReach with the key, handles the async 'progress' status by polling up to a few times before returning, and then sends the final JSON back to FlutterFlow. In the Firebase Console, open your project, go to Functions → Get Started (requires Blaze plan). Create a new HTTPS function called `lookupContact`. The function accepts a POST body with `name` and `currentEmployer` fields, calls the RocketReach v2 person-lookup endpoint, and handles the 'progress' status with a short polling loop (up to 3 retries, 2 seconds apart) before giving up and returning a 'not ready' response. Set your Api-Key as a Firebase Function environment variable via the Firebase console's Functions → Configuration section (key: `rr.api_key`), not hardcoded in the code below. Deploy the function — the deployment takes about 60 seconds. Note the function URL (e.g. `https://us-central1-your-project.cloudfunctions.net/lookupContact`) — you will paste this into FlutterFlow in the next step. For the 429 Retry-After scenario: if RocketReach returns HTTP 429 (too many requests), the response includes a `Retry-After` header indicating how many seconds to wait. Handle this in the Cloud Function by reading the header and returning a 429 with a clear message to FlutterFlow so the app can display a 'Please try again in X seconds' message rather than a generic error.

1const functions = require('firebase-functions');
2const axios = require('axios');
3
4// Set via Firebase Console → Functions → Configuration:
5// rr.api_key = YOUR_ROCKETREACH_API_KEY
6const RR_API_KEY = functions.config().rr.api_key;
7const RR_BASE_URL = 'https://api.rocketreach.co/api/v2';
8
9async function lookupWithRetry(name, currentEmployer, retries = 3) {
10  for (let i = 0; i < retries; i++) {
11    const res = await axios.get(`${RR_BASE_URL}/person/lookup`, {
12      headers: { 'Api-Key': RR_API_KEY },
13      params: { name, current_employer: currentEmployer }
14    });
15
16    const data = res.data;
17    if (data.status === 'complete' || data.status === 'failed') {
18      return data;
19    }
20    // status === 'progress' — wait and retry
21    if (i < retries - 1) {
22      await new Promise(resolve => setTimeout(resolve, 2000));
23    }
24  }
25  return { status: 'progress', message: 'Lookup is still processing. Try again shortly.' };
26}
27
28exports.lookupContact = functions.https.onRequest(async (req, res) => {
29  res.set('Access-Control-Allow-Origin', '*');
30  if (req.method === 'OPTIONS') {
31    res.set('Access-Control-Allow-Methods', 'POST');
32    res.set('Access-Control-Allow-Headers', 'Content-Type');
33    return res.status(204).send('');
34  }
35
36  const { name, currentEmployer } = req.body;
37  if (!name || !currentEmployer) {
38    return res.status(400).json({ error: 'name and currentEmployer are required' });
39  }
40
41  try {
42    const data = await lookupWithRetry(name, currentEmployer);
43    return res.json(data);
44  } catch (err) {
45    if (err.response?.status === 429) {
46      const retryAfter = err.response.headers['retry-after'] || '60';
47      return res.status(429).json({
48        error: 'Rate limit reached',
49        retry_after_seconds: parseInt(retryAfter, 10)
50      });
51    }
52    if (err.response?.status === 403) {
53      return res.status(403).json({ error: 'Plan does not include this lookup type' });
54    }
55    console.error(err.message);
56    return res.status(500).json({ error: 'RocketReach lookup failed' });
57  }
58});

With the Cloud Function deployed and tested, open your FlutterFlow project. Click 'API Calls' in the left navigation panel, then click the '+' (plus) button and choose 'Create API Group.' Name it 'RocketReach.' In the Base URL field, paste the base of your Cloud Function URL — everything up to (but not including) the function name path. For example: `https://us-central1-your-project.cloudfunctions.net`. Leave the Headers section empty — no Api-Key here, since it lives securely in the Cloud Function. Now create an API Call inside this group: click '+' → 'Create API Call' → name it 'LookupPerson.' Set the Method to POST. Set the Path to `/lookupContact`. Click the 'Body' tab, set Content-Type to `application/json`. Click '+ Add Body Field' and add two variables: `name` (type String) and `currentEmployer` (type String). In the body JSON template, both should appear as `{{ name }}` and `{{ currentEmployer }}`. Click the 'Response & Test' tab. Fill in the Variables section: `name` = 'Jane Doe', `currentEmployer` = 'Acme Corporation'. Click 'Test API Call.' If the function is live, you will see a JSON response. For a real person in your network, the response should include an `emails` array with objects containing `email` and `confidence` fields. Click 'Generate JSON Paths' — FlutterFlow will extract paths like `$.emails[0].email`, `$.emails[0].confidence`, `$.status`, and `$.name` that you can bind to UI widgets. If the lookup returns status 'progress' with an empty emails array, it means the Cloud Function's polling retries were exhausted — this is normal for obscure contacts. Your app UI should check `$.status` and display an informational message ('Contact lookup is processing — check back in a few seconds') rather than showing an empty list as though the search failed.

1// API Call reference configuration (match these settings in the FlutterFlow UI)
2// Group Name: RocketReach
3// Base URL: https://us-central1-YOUR_PROJECT.cloudfunctions.net
4//
5// Call Name: LookupPerson
6// Method: POST
7// Path: /lookupContact
8// Content-Type: application/json
9// Body: { "name": "{{ name }}", "currentEmployer": "{{ currentEmployer }}" }
10//
11// Generated JSON Paths:
12// Status:          $.status
13// Person name:     $.name
14// First email:     $.emails[0].email
15// Email confidence: $.emails[0].confidence
16// All emails:      $.emails
17// First phone:     $.phones[0].number
18// LinkedIn URL:    $.linkedin_url

On your contact-lookup screen in FlutterFlow, you need an input field for the person's name, an input field for their employer, a 'Find Contact' button, and a results area that shows the emails and confidence grades. Create two Page State variables: `lookupStatus` (String, default: 'idle') and `lookupEmails` (List of JSON, default: empty list). Add a TextField widget bound to a local variable `nameInput` and another for `employerInput`. Add a Button widget with the text 'Find Contact.' For the Button's action, open the Action Flow Editor (select the button → Actions panel → '+' to add action). Add a 'Set Page State' action that sets `lookupStatus` to 'loading.' Then add a 'Backend/API Call' action → select RocketReach → LookupPerson. Set `name` to the `nameInput` variable and `currentEmployer` to the `employerInput` variable. After the call, add a 'Set Page State' action that sets `lookupStatus` to the JSON path value `$.status` from the response, and sets `lookupEmails` to the JSON path `$.emails` from the response. In the UI results area, add a Conditional Widget that checks `lookupStatus`: if 'loading,' show a CircularProgressIndicator; if 'progress,' show a Text widget saying 'Lookup is processing — results may take a moment'; if 'failed' or 'not_found,' show 'No contact found'; otherwise show the emails ListView. Inside the emails ListView, bind each item to a Row with two Text widgets: one for `email` and one for `confidence` (styled in a lighter color). Add a copy-to-clipboard IconButton using FlutterFlow's built-in clipboard action bound to each email string. This flow gives users clear feedback at every stage — they are never staring at a blank screen wondering if the lookup worked. Because each tap of 'Find Contact' consumes a credit, add a client-side guard: disable the button and show a spinner during the `loading` state so users cannot accidentally double-tap and trigger two lookups.

1// Page State variables to create in FlutterFlow:
2// - lookupStatus: String, initial value = 'idle'
3// - lookupEmails: List<dynamic>, initial value = []
4//
5// Button action sequence in Action Flow Editor:
6// 1. Set State: lookupStatus = 'loading'
7// 2. API Call: RocketReach → LookupPerson
8//    Variables: name = nameInput, currentEmployer = employerInput
9// 3. Set State: lookupStatus = API Response → $.status
10// 4. Set State: lookupEmails = API Response → $.emails
11//
12// Conditional widget logic:
13// lookupStatus == 'loading'   → CircularProgressIndicator
14// lookupStatus == 'progress'  → Text('Lookup processing, check back shortly')
15// lookupStatus == 'failed'    → Text('No contact found')
16// lookupStatus == 'complete'  → ListView of email cards
17// else (idle)                 → empty / placeholder text

Because every lookup costs credits, you should cache results in Firestore (or Supabase) so the same person is only looked up once. Without caching, every time a user opens a contact's detail screen, your app would trigger a new paid API call — multiplying costs rapidly in a team environment. The caching pattern works like this: before calling the Cloud Function, check Firestore for an existing enrichment record keyed by a normalized version of the person's name + employer (e.g. `jane_doe_acme_corp`). If a record exists and is less than 30 days old, skip the API call and display the cached emails. If no record exists, call the Cloud Function, and on success write the result to Firestore with a timestamp. In FlutterFlow, implement this with a Backend Query on the contact detail page that reads from a Firestore collection called `enriched_contacts` with a document ID equal to the normalized key. In the 'On Page Load' action, check if the query returned data (use a Conditional action based on whether the Backend Query has results). If yes, skip straight to displaying the cached emails. If no, fire the LookupPerson API Call, write the result back to Firestore using an 'Update Firestore Record' action, and then display the returned emails. Also add a 'Refresh' button that bypasses the cache — some users legitimately need an up-to-date lookup after a contact changes jobs. The Refresh button can set a flag in Page State that tells the action flow to skip the cache check and write a fresh result back to Firestore after calling RocketReach.

1// Firestore collection: enriched_contacts
2// Document ID: normalized key, e.g. 'jane_doe_acme_corp'
3// Fields:
4//   emails: List<Map> (from $.emails)
5//   phones: List<Map> (from $.phones)
6//   linkedin_url: String
7//   cached_at: Timestamp
8//   lookup_name: String
9//   lookup_employer: String
10//
11// On page load action flow (pseudocode):
12// 1. Query Firestore: enriched_contacts/{normalizedKey}
13// 2. If document exists AND cached_at > NOW - 30 days:
14//      Set Page State: lookupEmails = document.emails
15//      Set lookupStatus = 'complete'
16// 3. Else:
17//      Call Cloud Function → LookupPerson
18//      Write result to Firestore enriched_contacts/{normalizedKey}
19//      Set Page State from response

RocketReach returns HTTP 429 with a `Retry-After` header when you hit the rate limit for your plan. The Cloud Function we built earlier passes this through to FlutterFlow as a 429 response with a `retry_after_seconds` field in the JSON body. You need to surface this gracefully in the app rather than showing a generic error. In your FlutterFlow action flow, after the LookupPerson API Call, add a Conditional action that checks the HTTP status code of the response. FlutterFlow's API Call result includes a `statusCode` field — if it equals 429, set a Page State variable `rateLimitMessage` to a formatted string like 'Too many lookups. Please wait 60 seconds and try again.' Display this in a SnackBar or an inline error Text widget bound to `rateLimitMessage`. For company lookup (if your RocketReach plan includes it), add a second API Call in the RocketReach group: name it 'LookupCompany,' method GET, path `/company/lookup`, with a query variable `name` (the company name). In the Cloud Function, add a separate handler for company lookups: receive a `companyName` field in the POST body, call `/api/v2/company/lookup?name=...`, and return the result. Company lookup returns fields like `name`, `domain`, `linkedin_url`, `size`, and `revenue` — map these with JSON Paths in FlutterFlow and bind them to a company-detail screen. Before spending time building the company-lookup screen, confirm with RocketReach support that your plan includes it — a 403 error from the company endpoint means you need to add the company-lookup add-on to your subscription. Keep this feature gated behind a check in the UI so that if the Cloud Function returns a 403, users see 'Company lookup requires a plan upgrade' rather than a confusing API error.

1// Add to the Cloud Function to handle company lookup:
2exports.lookupCompany = functions.https.onRequest(async (req, res) => {
3  res.set('Access-Control-Allow-Origin', '*');
4  if (req.method === 'OPTIONS') {
5    res.set('Access-Control-Allow-Methods', 'POST');
6    res.set('Access-Control-Allow-Headers', 'Content-Type');
7    return res.status(204).send('');
8  }
9
10  const { companyName } = req.body;
11  if (!companyName) {
12    return res.status(400).json({ error: 'companyName is required' });
13  }
14
15  try {
16    const rr = await axios.get(`${RR_BASE_URL}/company/lookup`, {
17      headers: { 'Api-Key': RR_API_KEY },
18      params: { name: companyName }
19    });
20    return res.json(rr.data);
21  } catch (err) {
22    if (err.response?.status === 403) {
23      return res.status(403).json({ error: 'Company lookup requires a plan upgrade' });
24    }
25    if (err.response?.status === 429) {
26      const retryAfter = err.response.headers['retry-after'] || '60';
27      return res.status(429).json({ error: 'Rate limited', retry_after_seconds: parseInt(retryAfter, 10) });
28    }
29    return res.status(500).json({ error: 'Company lookup failed' });
30  }
31});