How to Integrate Retool with Google Ads

The Google Ads API requires three authentication components: a developer token, OAuth 2.0 client credentials, and a user OAuth token. Step 1 — Developer token: Log into your Google Ads manager account (MCC). Navigate to Tools & Settings → Setup → API Center. Apply for API access if you haven't already. A test developer token is available immediately for testing against test accounts. Production access (real account data) requires applying for basic or standard access (approval takes 1–5 business days). Step 2 — Google Cloud OAuth credentials: Go to https://console.cloud.google.com. Create a project or use an existing one. Enable the 'Google Ads API' in APIs & Services → Library. Navigate to APIs & Services → Credentials → Create Credentials → OAuth 2.0 Client ID. Select Web Application. Add https://oauth2.googleapis.com and your Retool URL as authorized redirect URIs. Download the client JSON to get your client_id and client_secret. Step 3 — OAuth refresh token: Use Google's OAuth 2.0 playground (https://developers.google.com/oauthplayground) or a local script to authorize the Google Ads API scope (https://www.googleapis.com/auth/adwords) for your Google account. Exchange the authorization code for an access token and refresh token. Copy the refresh_token. Store all credentials in Retool Configuration Variables: GOOGLE_ADS_DEVELOPER_TOKEN (marked as secret), GOOGLE_ADS_CLIENT_ID, GOOGLE_ADS_CLIENT_SECRET (secret), GOOGLE_ADS_REFRESH_TOKEN (secret), and GOOGLE_ADS_CUSTOMER_ID.

Google Ads OAuth 2.0 access tokens expire after 1 hour. You need a mechanism to refresh them before building queries. Create a Retool JavaScript query called refreshGoogleAdsToken (set to run on page load): POST https://oauth2.googleapis.com/token with body: grant_type=refresh_token&client_id={{ retoolContext.configVars.GOOGLE_ADS_CLIENT_ID }}&client_secret={{ retoolContext.configVars.GOOGLE_ADS_CLIENT_SECRET }}&refresh_token={{ retoolContext.configVars.GOOGLE_ADS_REFRESH_TOKEN }} This returns a fresh access_token valid for 1 hour. Store this in a Retool variable: setVariable('googleAdsAccessToken', response.access_token). Now create the REST API Resource: Resources tab → Add Resource → REST API. Name: Google Ads API Base URL: https://googleads.googleapis.com Authentication: Bearer Token → {{ googleAdsAccessToken.value }} (references the variable set by the token refresh query). Add headers: - developer-token: {{ retoolContext.configVars.GOOGLE_ADS_DEVELOPER_TOKEN }} - login-customer-id: {{ retoolContext.configVars.GOOGLE_ADS_MANAGER_ACCOUNT_ID }} (only needed if accessing via MCC — omit if accessing a standalone account directly) Click Create Resource.

1// JavaScript query: refreshGoogleAdsToken
2// POST https://oauth2.googleapis.com/token
3// (Use a separate REST API Resource pointed at oauth2.googleapis.com for this query)
4const response = await fetch('https://oauth2.googleapis.com/token', {
5  method: 'POST',
6  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
7  body: [
8    `grant_type=refresh_token`,
9    `client_id=${retoolContext.configVars.GOOGLE_ADS_CLIENT_ID}`,
10    `client_secret=${retoolContext.configVars.GOOGLE_ADS_CLIENT_SECRET}`,
11    `refresh_token=${retoolContext.configVars.GOOGLE_ADS_REFRESH_TOKEN}`
12  ].join('&')
13});
14const data = await response.json();
15return data.access_token;

Google Ads API uses POST requests with GAQL query in the request body. All reporting queries go to: POST /v17/customers/{{ retoolContext.configVars.GOOGLE_ADS_CUSTOMER_ID }}/googleAds:search The request body is a JSON object with a single query field containing the GAQL string. Create a getCampaignPerformance query: POST /v17/customers/{customerId}/googleAds:search with body: { "query": "SELECT campaign.id, campaign.name, campaign.status, campaign.advertising_channel_type, metrics.impressions, metrics.clicks, metrics.ctr, metrics.average_cpc, metrics.conversions, metrics.cost_micros, metrics.roas FROM campaign WHERE campaign.status = 'ENABLED' AND segments.date DURING LAST_30_DAYS ORDER BY metrics.cost_micros DESC LIMIT 50" } GAQL key concepts: - Resources: campaign, ad_group, keyword_view, search_term_view, campaign_budget - Metrics: metrics.impressions, metrics.clicks, metrics.ctr, metrics.average_cpc, metrics.cost_micros (divide by 1,000,000 to get dollars), metrics.conversions, metrics.roas - Segments: segments.date, segments.device, segments.day_of_week - Date filters: WHERE segments.date DURING LAST_7_DAYS (also: LAST_30_DAYS, THIS_MONTH, LAST_MONTH) - Status filters: WHERE campaign.status = 'ENABLED' (values: ENABLED, PAUSED, REMOVED) Create a getKeywordPerformance query with a GAQL query targeting the ad_group_criterion resource with ad_group_criterion.type = 'KEYWORD'.

1// GAQL query for keyword performance
2// POST /v17/customers/{customerId}/googleAds:search
3{
4  "query": "SELECT ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.quality_info.quality_score, ad_group.name, campaign.name, metrics.impressions, metrics.clicks, metrics.ctr, metrics.average_cpc, metrics.conversions, metrics.cost_micros FROM ad_group_criterion WHERE ad_group_criterion.type = 'KEYWORD' AND ad_group_criterion.status = 'ENABLED' AND segments.date DURING LAST_30_DAYS ORDER BY metrics.impressions DESC LIMIT 200"
5}

Google Ads API GAQL responses have a nested structure. Each row in the response is an object with nested resource and metrics objects. Create a transformer to flatten this for the Table component. The response format from GAQL is: { results: [ { campaign: { id, name, status }, metrics: { impressions, clicks, ctr, average_cpc, cost_micros, conversions } }, ... ] } Create a campaignTransformer to flatten and compute derived metrics. Then bind to a Table component. For the keyword Quality Score dashboard, create a separate Table with color-coded Quality Score badges using Retool's Table column formatting: set the quality_score column to tag/badge type with rules — red for 1-4, yellow for 5-6, green for 7-10. Add summary Stat components above the Table: - Total Spend: sum of all campaign cost values - Total Clicks: sum of clicks - Average CTR: weighted average by impressions - Total Conversions: sum of conversions For a Chart comparing campaigns by spend vs. ROAS, use Retool's Chart component (Plotly.js). Create a scatter plot with x = ROAS and y = spend, with bubble size representing impressions. This visualizes the efficiency/scale relationship across all campaigns at a glance.

1// Transformer for GAQL campaign response
2const results = data?.results || [];
3return results.map(row => {
4  const campaign = row.campaign || {};
5  const metrics = row.metrics || {};
6  const budget = row.campaignBudget || {};
7
8  const costDollars = (metrics.costMicros || 0) / 1000000;
9  const ctr = parseFloat(metrics.ctr || 0) * 100;
10  const avgCpc = (metrics.averageCpc || 0) / 1000000;
11  const roas = metrics.conversionsValue > 0
12    ? (metrics.conversionsValue / costDollars).toFixed(2)
13    : '0.00';
14
15  return {
16    id: campaign.id,
17    name: campaign.name,
18    status: campaign.status,
19    channel: campaign.advertisingChannelType || '',
20    impressions: parseInt(metrics.impressions || 0).toLocaleString(),
21    clicks: parseInt(metrics.clicks || 0).toLocaleString(),
22    ctr: `${ctr.toFixed(2)}%`,
23    avg_cpc: `$${avgCpc.toFixed(2)}`,
24    spend: `$${costDollars.toFixed(2)}`,
25    spend_raw: costDollars,
26    conversions: parseFloat(metrics.conversions || 0).toFixed(1),
27    roas: roas,
28    conv_rate: metrics.clicks > 0
29      ? `${((metrics.conversions / metrics.clicks) * 100).toFixed(2)}%`
30      : '0.00%'
31  };
32});

Create a getSearchTerms query: POST /v17/customers/{customerId}/googleAds:search with GAQL: { "query": "SELECT search_term_view.search_term, campaign.name, ad_group.name, metrics.impressions, metrics.clicks, metrics.ctr, metrics.cost_micros, metrics.conversions FROM search_term_view WHERE segments.date DURING LAST_30_DAYS AND metrics.impressions > 10 ORDER BY metrics.cost_micros DESC LIMIT 500" } Filter the search term results in a transformer to identify 'waste' terms: high cost (> $5) with zero conversions. Display these in a separate 'Negative Keywords Candidates' Table to help PPC managers identify irrelevant queries. For multi-account support (MCC/manager accounts), create a getAccessibleCustomers query: GET /v17/customers:listAccessibleCustomers. This returns all Google Ads accounts accessible to the authenticated user. Build a customer Select component and dynamically replace the customer ID in all query paths based on the selection. For the budget pacing calculation, fetch campaign budget data: SELECT campaign.name, campaign_budget.amount_micros FROM campaign WHERE campaign.status = 'ENABLED'. Compute pacing status in a transformer using the current day of month and total days in the current month. For PPC teams managing multiple Google Ads accounts across complex agency or enterprise setups, combining GAQL reporting with automated budget alerts, bid change tracking, and internal dashboard distribution, RapidDev's team can help architect the complete Retool solution.

1// Transformer: identify negative keyword candidates
2const terms = data?.results || [];
3const formatted = terms.map(row => ({
4  term: row.searchTermView?.searchTerm || '',
5  campaign: row.campaign?.name || '',
6  ad_group: row.adGroup?.name || '',
7  impressions: parseInt(row.metrics?.impressions || 0),
8  clicks: parseInt(row.metrics?.clicks || 0),
9  cost: (row.metrics?.costMicros || 0) / 1000000,
10  conversions: parseFloat(row.metrics?.conversions || 0)
11}));
12
13// Flag waste: cost > $2, conversions = 0, impressions > 20
14const negativeCandidates = formatted.filter(t =>
15  t.cost > 2 && t.conversions === 0 && t.impressions > 20
16);
17
18return {
19  all_terms: formatted,
20  negative_candidates: negativeCandidates.sort((a, b) => b.cost - a.cost),
21  total_waste: negativeCandidates.reduce((sum, t) => sum + t.cost, 0).toFixed(2)
22};