Datanyze

The first step is clarifying what Datanyze is today (2026) so you can make an informed technology choice. Datanyze was acquired by ZoomInfo in 2021. Post-acquisition, Datanyze was repositioned as a lightweight contact-lookup Chrome extension for ZoomInfo's ecosystem — the product now surfaces contact information and basic company data directly in a browser sidebar when visiting company websites or LinkedIn profiles. The standalone technographic database and API that Datanyze offered pre-acquisition was absorbed into ZoomInfo's platform and is no longer accessible as a separate developer product. Datanyze's website at datanyze.com currently describes and sells only the Chrome extension product. There is no API reference, no API key generation, no developer console, and no webhooks. For a FlutterFlow app, the practical alternatives based on your use case are: (1) BuiltWith API (builtwith.com/api) — purpose-built for technology-stack detection by domain, with a REST API returning categorized technology lists; plans start around $295/mo but have been known to change (verify current pricing). (2) Clearbit Enrichment (clearbit.com) — company and person enrichment from domain or email, with clean REST endpoints and good documentation; pricing is per lookup with volume plans. (3) ZoomInfo API — Datanyze's parent company, with the most comprehensive firmographic and technographic database, but targeted at enterprise teams with correspondingly enterprise-level pricing (contact sales). For most FlutterFlow founders, BuiltWith or Clearbit is the practical starting point. This tutorial uses BuiltWith as the primary example but the proxy pattern is identical for all three.

Go to builtwith.com/api and sign up for an API plan. After signing up, log in and navigate to the API section of your account dashboard to find your API key. The BuiltWith API endpoint for a domain technology lookup is: https://api.builtwith.com/v21/api.json?KEY={your_api_key}&LOOKUP={domain}. Replace {your_api_key} with your actual key and {domain} with a company domain like example.com. Test this in your browser or with curl to see the response structure — BuiltWith returns a detailed JSON object with a Results array, inside which each technology is listed under technology categories. Key response fields you will map in FlutterFlow: Results[0].Result.Paths[0].Technologies[] is the array of detected technologies; each technology object has a Name, Tag (category like 'analytics', 'cdn', 'cms'), and FirstDetected/LastDetected timestamps. The response can be large (many kilobytes for tech-heavy websites), so consider having your Cloud Function filter or summarize the data before returning it to FlutterFlow — returning only the technology names and categories rather than the full raw response. Note: BuiltWith's API pricing and specific plan tiers change periodically. Verify the current pricing on their website before building your integration, and check whether your plan allows bulk domain lookups or only single-domain-at-a-time queries.

1# Test BuiltWith API (replace values)
2curl 'https://api.builtwith.com/v21/api.json?KEY=YOUR_API_KEY&LOOKUP=example.com'
3
4# Expected response structure:
5# {
6#   "Results": [
7#     {
8#       "Result": {
9#         "Paths": [
10#           {
11#             "Technologies": [
12#               { "Name": "Google Analytics", "Tag": "analytics", "FirstDetected": 1234567890 },
13#               { "Name": "Cloudflare", "Tag": "cdn", "FirstDetected": 1234567890 }
14#             ]
15#           }
16#         ]
17#       }
18#     }
19#   ]
20# }

The BuiltWith API key is a secret that cannot live in the FlutterFlow app binary. Build a Firebase Cloud Function that accepts a domain from FlutterFlow, makes the BuiltWith API call server-side, and returns a clean simplified technology list to the app. In Firebase Console → Functions → Get started, create functions/index.js with the code below. The function accepts a domain parameter in the POST body, calls the BuiltWith API with the key stored in Firebase environment config, extracts and simplifies the technology list from the response, and returns a clean JSON array. Deploy the function with the Firebase CLI. Set your BuiltWith API key as an environment config variable (not hardcoded in the file). Once deployed, you will receive a URL like https://us-central1-{project}.cloudfunctions.net/enrichmentProxy. If you are using Clearbit instead of BuiltWith, replace the BuiltWith URL in the function with https://company.clearbit.com/v2/companies/find?domain={domain}, change the Authorization header to Bearer {your_clearbit_key}, and adjust the response extraction to Clearbit's schema (fields: name, description, metrics.employees, category.industry, logo).

1// Firebase Cloud Function: functions/index.js
2const functions = require('firebase-functions');
3const axios = require('axios');
4
5const BUILTWITH_KEY = functions.config().builtwith.apikey;
6
7exports.enrichmentProxy = functions.https.onRequest(async (req, res) => {
8  res.set('Access-Control-Allow-Origin', '*');
9  if (req.method === 'OPTIONS') {
10    res.set('Access-Control-Allow-Methods', 'POST');
11    res.set('Access-Control-Allow-Headers', 'Content-Type');
12    return res.status(204).send('');
13  }
14
15  const { domain } = req.body;
16  if (!domain) {
17    return res.status(400).json({ error: 'domain is required' });
18  }
19
20  try {
21    const response = await axios.get(
22      `https://api.builtwith.com/v21/api.json?KEY=${BUILTWITH_KEY}&LOOKUP=${domain}`
23    );
24
25    // Extract and simplify the technology list
26    const technologies = [];
27    const paths = response.data?.Results?.[0]?.Result?.Paths || [];
28    for (const path of paths) {
29      for (const tech of (path.Technologies || [])) {
30        if (!technologies.find(t => t.name === tech.Name)) {
31          technologies.push({
32            name: tech.Name,
33            category: tech.Tag,
34            firstDetected: tech.FirstDetected,
35            lastDetected: tech.LastDetected
36          });
37        }
38      }
39    }
40
41    return res.json({
42      domain,
43      technology_count: technologies.length,
44      technologies: technologies.slice(0, 50) // cap at 50 for mobile display
45    });
46  } catch (err) {
47    return res.status(err.response?.status || 500).json({ error: err.message });
48  }
49});
50
51// Setup:
52// firebase functions:config:set builtwith.apikey="YOUR_BUILTWITH_KEY"
53// firebase deploy --only functions

Open your FlutterFlow project. Click API Calls in the left navigation. Click + Add → Create API Group. Name it EnrichmentProxy and set the Base URL to your Firebase Cloud Function URL (e.g. https://us-central1-{project}.cloudfunctions.net/enrichmentProxy). Add a Content-Type: application/json header. Add an API Call inside the group. Name it LookupDomain. Set method to POST. Leave the endpoint blank (the base URL is the full path). Click the Body tab, set body type to JSON, and add the body: { "domain": "{{domain}}" }. Add a variable named domain (String, no default). Click Response & Test, set domain to a test domain (e.g. stripe.com), and click Test API. You should see the technology list response from your Cloud Function. Click Generate JSON Paths to create path variables. Key paths: $.domain, $.technology_count, $.technologies[:].name, $.technologies[:].category. On your app screen, add a Column with a TextField at the top (bound to a Page State variable called searchDomain), a Button labeled 'Look up technologies', and a ListView below. Wire the button's action flow to: 1) Call LookupDomain with domain set to searchDomain Page State value, 2) Store the result in a Page State variable called techResults. For the ListView, use techResults as the data source. In each ListView card, show the technology name as the primary text and the category as a badge. Group technologies by category using a TabBar at the top (Analytics, CRM, E-commerce, CDN, Advertising) and filter the ListView by selected tab category.

1{
2  "group": "EnrichmentProxy",
3  "name": "LookupDomain",
4  "method": "POST",
5  "endpoint": "",
6  "body": {
7    "domain": "{{domain}}"
8  },
9  "variables": [
10    { "name": "domain", "type": "String" }
11  ],
12  "response_json_paths": [
13    "$.domain",
14    "$.technology_count",
15    "$.technologies[:].name",
16    "$.technologies[:].category"
17  ]
18}

A practical concern with any per-domain enrichment API (BuiltWith, Clearbit, ZoomInfo) is that lookups consume credits or count against a request quota. Looking up the same domain repeatedly wastes quota and costs money. The solution is to cache results in Firestore: the first time a domain is looked up, your Cloud Function stores the result in a Firestore document at /enrichment/{domain}. On subsequent lookups for the same domain, the Cloud Function reads from Firestore first and only calls the enrichment API if the cache is empty or older than 30 days. Update your Cloud Function to check Firestore before making the external API call. In FlutterFlow, the API Call and response structure remain identical — the caching is transparent. This also means you can pre-populate Firestore with Datanyze CSV export data if your team has exported records from the Datanyze Chrome extension, and the FlutterFlow app will surface that data through the same lookup interface without needing to call any external API for those domains. For teams that absolutely require the Datanyze Chrome extension's specific data set rather than an alternative API, the only supported path is: export data from Datanyze manually as a CSV, upload it to Firestore using a one-time script, and have FlutterFlow read from Firestore natively through Firebase's panel in FlutterFlow's Settings & Integrations. This keeps the data in your own database and avoids any API dependency entirely.

1// Updated Cloud Function with Firestore caching
2const functions = require('firebase-functions');
3const axios = require('axios');
4const admin = require('firebase-admin');
5admin.initializeApp();
6const db = admin.firestore();
7
8const BUILTWITH_KEY = functions.config().builtwith.apikey;
9const CACHE_DAYS = 30;
10
11exports.enrichmentProxy = functions.https.onRequest(async (req, res) => {
12  res.set('Access-Control-Allow-Origin', '*');
13  if (req.method === 'OPTIONS') {
14    res.set('Access-Control-Allow-Methods', 'POST');
15    res.set('Access-Control-Allow-Headers', 'Content-Type');
16    return res.status(204).send('');
17  }
18
19  const { domain } = req.body;
20  if (!domain) return res.status(400).json({ error: 'domain is required' });
21
22  // Check Firestore cache first
23  const cacheRef = db.collection('enrichment').doc(domain.replace(/\./g, '_'));
24  const cached = await cacheRef.get();
25  if (cached.exists) {
26    const data = cached.data();
27    const ageMs = Date.now() - data.cachedAt;
28    if (ageMs < CACHE_DAYS * 24 * 60 * 60 * 1000) {
29      return res.json(data.result);
30    }
31  }
32
33  try {
34    const response = await axios.get(
35      `https://api.builtwith.com/v21/api.json?KEY=${BUILTWITH_KEY}&LOOKUP=${domain}`
36    );
37    const paths = response.data?.Results?.[0]?.Result?.Paths || [];
38    const technologies = [];
39    for (const path of paths) {
40      for (const tech of (path.Technologies || [])) {
41        if (!technologies.find(t => t.name === tech.Name)) {
42          technologies.push({ name: tech.Name, category: tech.Tag });
43        }
44      }
45    }
46    const result = { domain, technology_count: technologies.length, technologies: technologies.slice(0, 50) };
47    await cacheRef.set({ result, cachedAt: Date.now() });
48    return res.json(result);
49  } catch (err) {
50    return res.status(err.response?.status || 500).json({ error: err.message });
51  }
52});