Google Ads

You need three separate things before writing any code. First, go to console.cloud.google.com, create or select a project, enable the Google Ads API, then go to APIs & Services → Credentials → Create Credentials → OAuth client ID. Choose Web application type and add https://developers.google.com/oauthplayground as an authorized redirect URI. Download the client credentials JSON — it contains your client_id and client_secret. Second, use the OAuth Playground at https://developers.google.com/oauthplayground to generate a refresh token: in the top-right gear icon, paste your client_id and client_secret and check 'Use your own OAuth credentials'. In Step 1, find the Google Ads API scope and select https://www.googleapis.com/auth/adwords. Authorize, exchange the code, and copy the refresh_token — this is the credential you will use to generate short-lived Bearer tokens inside your proxy. Third, obtain a developer token: log into the Google Ads API Center at https://developers.google.com/google-ads/api/docs/get-started/dev-token with a Google Ads Manager account, apply for a developer token, and wait for Basic access approval. Developer tokens start in test-only mode and cannot access real customer data until approved. All three values — client_id, client_secret, refresh_token, and developer_token — go into your backend environment variables only. The customer_id (your Google Ads account ID without hyphens) is not a secret and will be sent as a variable from FlutterFlow.

Create a Firebase Cloud Function that handles the entire Google Ads auth chain and executes GAQL queries on behalf of FlutterFlow. The function must do two things in sequence on every request: first, use the refresh token to obtain a fresh OAuth Bearer token by calling Google's token endpoint; then, use that Bearer token plus the developer token to POST a GAQL query to the Google Ads API. The Google Ads API endpoint format is https://googleads.googleapis.com/v18/customers/{customer_id}/googleAds:searchStream (or :search for paginated results). GAQL queries look like SQL: SELECT campaign.name, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions FROM campaign WHERE segments.date DURING LAST_30_DAYS ORDER BY metrics.impressions DESC. The proxy must also include CORS headers for FlutterFlow web builds. If using MCC access, add the login-customer-id header alongside the developer token. The function must handle Google's 429 responses which include a Retry-After header — log the retry value and return a 429 upstream so the app can display an appropriate message. Deploy from your local machine using the Firebase CLI and copy the HTTPS trigger URL for use in FlutterFlow.

1// functions/index.js (Firebase Cloud Functions)
2const functions = require('firebase-functions');
3const fetch = require('node-fetch');
4
5const { CLIENT_ID, CLIENT_SECRET, REFRESH_TOKEN, DEVELOPER_TOKEN } = process.env;
6
7async function getAccessToken() {
8  const res = await fetch('https://oauth2.googleapis.com/token', {
9    method: 'POST',
10    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
11    body: new URLSearchParams({
12      client_id: CLIENT_ID,
13      client_secret: CLIENT_SECRET,
14      refresh_token: REFRESH_TOKEN,
15      grant_type: 'refresh_token'
16    })
17  });
18  const { access_token } = await res.json();
19  return access_token;
20}
21
22exports.googleAdsProxy = functions.https.onRequest(async (req, res) => {
23  res.set('Access-Control-Allow-Origin', '*');
24  res.set('Access-Control-Allow-Methods', 'POST, OPTIONS');
25  res.set('Access-Control-Allow-Headers', 'Content-Type');
26  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
27
28  const { customer_id, gaql_query, login_customer_id } = req.body;
29  if (!customer_id || !gaql_query) {
30    res.status(400).json({ error: 'customer_id and gaql_query required' });
31    return;
32  }
33
34  const accessToken = await getAccessToken();
35  const headers = {
36    'Authorization': `Bearer ${accessToken}`,
37    'developer-token': DEVELOPER_TOKEN,
38    'Content-Type': 'application/json'
39  };
40  if (login_customer_id) headers['login-customer-id'] = login_customer_id;
41
42  const gaRes = await fetch(
43    `https://googleads.googleapis.com/v18/customers/${customer_id}/googleAds:search`,
44    { method: 'POST', headers, body: JSON.stringify({ query: gaql_query }) }
45  );
46  const data = await gaRes.json();
47  if (gaRes.status === 429) {
48    const retryAfter = gaRes.headers.get('Retry-After');
49    res.set('Retry-After', retryAfter || '60');
50  }
51  res.status(gaRes.status).json(data);
52});
53

In FlutterFlow, click API Calls in the left navigation panel, then click + Add → Create API Group. Name it GoogleAdsProxy and paste your Firebase Cloud Function HTTPS trigger URL as the Base URL. No headers are needed at the group level — all credentials are handled server-side. Create an API Call inside the group named getCampaignMetrics. Set the HTTP method to POST and leave the endpoint path blank. In the Body tab, select JSON and add three variables: customer_id (String), gaql_query (String), and login_customer_id (String, optional — pass an empty string if not needed). Your JSON body template: { "customer_id": "{{customer_id}}", "gaql_query": "{{gaql_query}}", "login_customer_id": "{{login_customer_id}}" }. In Response & Test, fill in a real customer_id (digits only, no hyphens like 1234567890) and a GAQL query string. Click Test. A successful response has a results array with objects containing campaign.name, metrics.impressions, metrics.clicks, and metrics.cost_micros (spend in micros — divide by 1,000,000 for dollars). Click Generate from Response to build JSON Path expressions automatically. The nested path structure in the Google Ads API response is: $.results[*].campaign.name, $.results[*].metrics.impressions, $.results[*].metrics.cost_micros, and so on.

1{
2  "customer_id": "{{customer_id}}",
3  "gaql_query": "{{gaql_query}}",
4  "login_customer_id": "{{login_customer_id}}"
5}

GAQL (Google Ads Query Language) looks like SQL but targets Google Ads resources. Every GAQL query has a FROM clause that names the primary resource (campaign, ad_group, keyword_view, search_term_view) and a SELECT clause listing the fields you want. Metrics like impressions, clicks, and conversions always live under metrics.*. Resource attributes live under the resource name — campaign.name, ad_group.name, keyword.text. Segments like date, day_of_week, and device live under segments.*. A useful starting query for campaign-level performance: SELECT campaign.name, campaign.status, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions, metrics.average_cpc FROM campaign WHERE campaign.status = 'ENABLED' AND segments.date DURING LAST_30_DAYS ORDER BY metrics.cost_micros DESC. In FlutterFlow, create a Data Type called CampaignResult with fields: campaignName (String), status (String), impressions (Integer), clicks (Integer), costMicros (Integer), conversions (Double), averageCpc (Integer). Map the JSON Paths from your test response to these fields. Note that cost_micros is an integer representing millionths of currency units — divide by 1000000 in FlutterFlow using a computed property or format it in the proxy before returning. Build a dashboard screen with a ListView bound to the getCampaignMetrics Backend Query, passing the customer_id from the user's app profile. Inside each list item, show campaignName, formatted spend (costMicros / 1000000), clicks, and conversions in a Card widget.

1-- Example GAQL queries for common use cases
2
3-- Campaign performance last 30 days
4SELECT campaign.name, campaign.status,
5  metrics.impressions, metrics.clicks,
6  metrics.cost_micros, metrics.conversions,
7  metrics.average_cpc
8FROM campaign
9WHERE campaign.status = 'ENABLED'
10  AND segments.date DURING LAST_30_DAYS
11ORDER BY metrics.cost_micros DESC
12
13-- Keyword performance with Quality Score
14SELECT
15  ad_group_criterion.keyword.text,
16  ad_group_criterion.quality_info.quality_score,
17  metrics.impressions, metrics.clicks,
18  metrics.average_cpc
19FROM keyword_view
20WHERE campaign.status = 'ENABLED'
21  AND ad_group.status = 'ENABLED'
22  AND ad_group_criterion.status = 'ENABLED'
23  AND segments.date DURING LAST_30_DAYS
24ORDER BY metrics.clicks DESC
25LIMIT 50
26

The Google Ads API allows 15,000 requests per day and 1,000 per minute per developer token. These limits apply across all customer accounts your token can access — not per account. If you query many customer accounts in parallel or on every screen open, you can exhaust the per-minute limit quickly. The proxy should serialize requests (not fire parallel GAQL calls simultaneously) and cache results in Firestore for at least 15 minutes so concurrent app sessions share a single upstream call. When the API returns a 429 response, it includes a Retry-After header telling you how many seconds to wait. Your proxy should pass this value through to FlutterFlow in a Retry-After response header, and FlutterFlow's action flow should check the API Call's response status and show a 'Data temporarily unavailable — please try again in X seconds' message rather than displaying empty results. For multi-account MCC dashboards, serialize queries per account and add a short delay between each to stay well under the per-minute ceiling. Add the Firestore caching pattern inside your Cloud Function: check for a cached document keyed by customer_id + query hash before calling Google, and write the fresh response back to Firestore after every upstream call. If you need help building a multi-account caching proxy or the MCC query serialization logic, RapidDev's team builds FlutterFlow integrations like this every week — free scoping call at rapidevelopers.com/contact.

1// Caching and rate-limit handling inside googleAdsProxy function
2const crypto = require('crypto');
3const admin = require('firebase-admin');
4if (!admin.apps.length) admin.initializeApp();
5const db = admin.firestore();
6
7const queryHash = crypto
8  .createHash('md5')
9  .update(customer_id + gaql_query)
10  .digest('hex');
11const cacheRef = db.collection('gads_cache').doc(queryHash);
12const cached = await cacheRef.get();
13
14if (cached.exists && !req.body.force_refresh) {
15  const { payload, cached_at } = cached.data();
16  if (Date.now() - cached_at < 15 * 60 * 1000) {
17    res.json({ ...payload, from_cache: true });
18    return;
19  }
20}
21
22// ... GAQL fetch to Google Ads API ...
23// After receiving data:
24await cacheRef.set({ payload: data, cached_at: Date.now() });
25res.json({ ...data, from_cache: false });
26