Serpstat

Serpstat's token goes in the URL query string (?token=...), which means it appears in HTTP access logs at any intermediate point and is embedded in the compiled Flutter binary if placed in a FlutterFlow API Call variable. The Cloud Function proxy solves this and also provides the 429 backoff that FlutterFlow API Calls cannot do natively — FlutterFlow has no built-in retry mechanism, so hammering Serpstat when the per-second limit is exceeded would silently fail without a retry. Create an HTTP Cloud Function. The function receives the method and params from FlutterFlow in its POST body, reads the token from process.env.SERPSTAT_TOKEN, builds the Serpstat v4 URL with the token appended, and POSTs the JSON-RPC body to it. Add simple 429 retry logic: if Serpstat returns 429, wait 1 second and retry once before returning the error to FlutterFlow. Set the token: firebase functions:config:set serpstat.token='YOUR_TOKEN'. Add Access-Control-Allow-Origin: * headers for FlutterFlow web builds. Deploy with firebase deploy --only functions. Test by POSTing {"method": "SerpstatDomainProcedure.getDomainInfo", "params": {"domain": "example.com", "se": "g_us"}} to your function URL and confirming you get a JSON response with result.data.

1// Firebase Cloud Function proxy for Serpstat (functions/index.js)
2const functions = require('firebase-functions');
3const axios     = require('axios');
4
5const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
6
7exports.serpstatProxy = functions.https.onRequest(async (req, res) => {
8  res.set('Access-Control-Allow-Origin', '*');
9  res.set('Access-Control-Allow-Methods', 'POST, OPTIONS');
10  res.set('Access-Control-Allow-Headers', 'Content-Type');
11  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
12  if (req.method !== 'POST') {
13    return res.status(405).json({ error: 'POST required' });
14  }
15
16  const token  = process.env.SERPSTAT_TOKEN;
17  const method = req.body?.method;
18  const params = req.body?.params || {};
19
20  if (!method) {
21    return res.status(400).json({ error: 'method is required' });
22  }
23
24  const url = `https://api.serpstat.com/v4?token=${token}`;
25  const body = { id: 1, method, params };
26
27  const doRequest = async (attempt) => {
28    try {
29      const response = await axios.post(url, body, {
30        headers: { 'Content-Type': 'application/json' },
31        timeout: 15000
32      });
33      return response.data;
34    } catch (err) {
35      if (err.response?.status === 429 && attempt === 1) {
36        await sleep(1000);
37        return doRequest(2);
38      }
39      throw err;
40    }
41  };
42
43  try {
44    const data = await doRequest(1);
45    res.json(data);
46  } catch (err) {
47    const status = err.response?.status || 500;
48    res.status(status).json({ error: err.message });
49  }
50});

In FlutterFlow, navigate to API Calls in the left nav. Click + Add → Create API Group. Name it Serpstat. In the Base URL field, paste your Cloud Function URL: https://us-central1-YOUR_PROJECT.cloudfunctions.net/serpstatProxy. Since your proxy handles authentication internally, you do not need any Authorization headers at the group level. However, you may want to add an optional X-App-Key header with a static secret UUID that your Cloud Function checks — this restricts your proxy so only your FlutterFlow app can call it, rather than anyone who discovers the Cloud Function URL. Save the group. The Serpstat group now appears in the left nav, ready for API Call definitions. The key insight here is that unlike Ahrefs (separate calls per endpoint) or Moz (one endpoint, one purpose), you will create just ONE API Call inside this group — because Serpstat's single URL handles all report types via the method body field.

Because Serpstat uses a JSON-RPC design, you only need one API Call. The method field in the body determines which report runs. You will pass method and params as FlutterFlow body Variables, making this call reusable across different screens with different report needs. Click + inside the Serpstat group → Create API Call. Name it Serpstat Query. Set the HTTP Method to POST. Set the Body Type to JSON. Go to the Variables tab and add: - method (String, required) — e.g. 'SerpstatDomainProcedure.getDomainInfo' - domain (String, required) — the domain to query - se (String, default: g_us) — the search engine/country database (g_us, g_uk, g_de, etc.) - limit (Integer, default: 100) — max rows of keyword data to return In the Body field, use this JSON template: {"method": "{{method}}", "params": {"domain": "{{domain}}", "se": "{{se}}", "size": {{limit}}}} Note: for keyword methods (SerpstatKeywordProcedure.getKeywordInfo), replace 'domain' in params with 'keyword'. You can handle this by adding a keyword variable and building two API Calls (one for domain methods, one for keyword methods) — or use a single flexible call with both variables and let the proxy pick the right one. Switch to Response & Test. Fill in method=SerpstatDomainProcedure.getDomainInfo, domain=example.com, se=g_us. Run the test. The JSON response will have a result.data object with fields like keyword_count, traff, traff_cost. Click Generate JSON Paths. Map: $.result.data.keyword_count → keywordCount, $.result.data.traff → estimatedTraffic, $.result.data.traff_cost → trafficCost.

1// API Call POST body template
2{
3  "method": "{{method}}",
4  "params": {
5    "domain": "{{domain}}",
6    "se": "{{se}}",
7    "size": {{limit}}
8  }
9}
10
11// Common Serpstat methods to use as the 'method' variable:
12// Domain reports:
13//   SerpstatDomainProcedure.getDomainInfo         — overall domain metrics
14//   SerpstatDomainProcedure.getDomainKeywords     — organic keyword list
15//   SerpstatDomainProcedure.getCompetitors        — domain competitors
16// Keyword reports:
17//   SerpstatKeywordProcedure.getKeywordInfo       — keyword volume + CPC
18//   SerpstatKeywordProcedure.getRelatedKeywords   — related keywords list
19
20// JSON Paths for getDomainInfo response:
21// keywordCount    → $.result.data.keyword_count
22// estimatedTraff  → $.result.data.traff
23// trafficCost     → $.result.data.traff_cost
24// visibilityScore → $.result.data.visible_percentage

Serpstat's responses nest data inside result.data — for domain methods it is a single object, and for keyword list methods (getDomainKeywords, getRelatedKeywords) it is an array at $.result.data[*]. FlutterFlow's JSON Path tool handles both, but you need to configure your JSON Paths correctly for each case. For domain overview data (getDomainInfo): the JSON Path $.result.data.keyword_count extracts a single integer. Bind it directly to a Text widget on your dashboard card. For keyword list data (getDomainKeywords): the JSON Path $.result.data[*].keyword extracts all keyword strings as a list, and $.result.data[*].traff extracts the corresponding traffic values. In FlutterFlow, create a custom Data Type called SerpstatKeyword with fields: keyword (String), traff (int), cost (double), keyword_length (int), concurrency (int). Use the API Call's JSON Path list extraction to generate a list of SerpstatKeyword items, then bind the list to a ListView whose list tile widgets display keyword name and volume. On your domain overview screen, add a Row with three metric Cards: Keyword Count, Estimated Traffic, and Traffic Cost Value. Bind each to the relevant App State variable populated by the API Call action. For the keyword list screen, add a ListView bound to the list returned by the getDomainKeywords call, with each item showing the keyword and its traffic estimate. Add a search/filter bar above the ListView so users can narrow the keyword list without making a new API call.

Now connect all the pieces into a working app flow. On your main screen, add a TextField for domain input and a Search button. In the Search button's Actions panel: 1. Validate the TextField is not empty. 2. Set App State variable isLoading = true. 3. Backend/API Call → Serpstat → Serpstat Query, with method = 'SerpstatDomainProcedure.getDomainInfo', domain = TextField value, se = currently selected database, limit = 100. 4. On success: update App State with the parsed JSON Path values (keywordCount, estimatedTraffic, trafficCost). Set isLoading = false. 5. On error: show a Dialog — if the error is a 429 response, display 'Serpstat rate limit reached — please wait a moment.' If it's a 401, display 'Invalid token — check your Serpstat API configuration.' For unit conservation, add a lastSearched App State variable (String, stores the last-queried domain). At the start of the Search action, check if the domain TextField matches lastSearched AND the App State metrics are not null — if both are true, skip the API call and display the cached App State values with a toast 'Showing cached result'. This saves a credit on repeated searches for the same domain. If you'd rather skip the custom action and proxy setup and have a FlutterFlow expert wire this for you, RapidDev's team builds integrations like this every week — free scoping call at rapidevelopers.com/contact.