How to Integrate Retool with SEMrush

Navigate to the Resources tab in your Retool instance and click Add Resource. Select REST API from the list of resource types. Name the resource 'SEMrush API'. In the Base URL field, enter https://api.semrush.com. All SEMrush API endpoints are accessed via this base URL with report-specific query parameters appended to each query. SEMrush authenticates API requests using an API key passed as a URL query parameter named key. Rather than adding it to each query individually, add it as a default URL parameter at the resource level. In the URL Parameters section, click Add Parameter and set the name to key and the value to your SEMrush API key. For better security, store the API key as a configuration variable. Go to Retool's Settings → Configuration Variables, create a variable named SEMRUSH_API_KEY, mark it as Secret, and paste your key. Then in the resource's URL parameter value field, use {{ retoolContext.configVars.SEMRUSH_API_KEY }} instead of the raw key. SEMrush's API responses use a pipe-delimited text format (not JSON) for most reporting endpoints. Each response includes a header row followed by data rows, all separated by semicolons or pipes depending on the endpoint. You will use JavaScript transformers to parse this format. Leave all other resource settings at their defaults and click Save Changes.

Create your first SEMrush query to retrieve domain overview metrics. In your Retool app, open the Code panel and click + to add a query. Name it getDomainAnalytics and select the SEMrush API resource. Set Method to GET. In the Path field, leave it empty (SEMrush's reporting API uses the base URL with query parameters). Add the following URL parameters to build the report request: - type: domain_ranks (this report type returns organic and paid traffic metrics for a domain) - domain: {{ textInput_domain.value }} (the domain to analyze, e.g., example.com) - database: us (the SEMrush database — us for US data, uk for UK, etc.) - export_columns: Dn,Rk,Or,Ot,Oc,Ad,At,Ac (columns: Domain, Rank, Organic Keywords, Organic Traffic, Organic Cost, Adwords Keywords, Adwords Traffic, Adwords Cost) - display_limit: 1 SEMrush returns this data as pipe-delimited text. Add a JavaScript transformer to parse it: For the keyword list query, create a second query named getDomainKeywords: - type: domain_organic - domain: {{ textInput_domain.value }} - database: us - export_columns: Ph,Po,Pp,Pd,Nq,Cp,Co,Kd,Tr,Tc,In,Ur,Fk,Ts (Phrase, Position, Previous Position, Position Diff, Volume, CPC, Competition, KD, Traffic, Traffic Cost, Number of Results, URL, Featured Snippet, Timestamp) - display_limit: 100 - display_sort: tr_desc (sort by traffic descending) Bind getDomainKeywords to a Table component and add a text input filter for keyword phrase matching.

1// JavaScript transformer — parse SEMrush pipe-delimited response
2// SEMrush returns: header_row\n data_row1\n data_row2\n ...
3const responseText = data; // raw API response text
4
5if (!responseText || typeof responseText !== 'string') {
6  return [];
7}
8
9const lines = responseText.trim().split('\n').filter(l => l.trim());
10if (lines.length < 2) return []; // No data rows
11
12const headers = lines[0].split(';');
13
14return lines.slice(1).map(line => {
15  const values = line.split(';');
16  const row = {};
17  headers.forEach((header, i) => {
18    row[header.trim()] = values[i] ? values[i].trim() : '';
19  });
20  return row;
21}).filter(row => Object.values(row).some(v => v !== ''));

Build detailed keyword ranking queries that show position changes over time. Create a query named getKeywordPositionHistory: - Path: leave empty (use URL parameters only) - URL parameters: - type: domain_organic - domain: {{ textInput_domain.value }} - database: us - export_columns: Ph,Po,Pp,Pd,Nq,Cp,Kd,Ur - display_filter: +|Po|Lt|11 (filter to page 1 rankings, position less than 11) - display_sort: nq_desc (sort by search volume) - display_limit: 50 The Pp (Previous Position) and Pd (Position Difference) columns in SEMrush's domain_organic report show week-over-week changes. Add a JavaScript transformer that calculates a change_direction field: 'improved' when Pd is negative (lower position number = better), 'declined' when Pd is positive, and 'stable' when 0. In your Retool Table component, add conditional column formatting to the position change column: green background for improved keywords, red for declined, gray for stable. For tracking specific keywords (not domain-wide), create a keyword_overview query: - type: phrase_this - phrase: {{ textInput_keyword.value }} - database: us - export_columns: Ph,Nq,Cp,Co,Nr,Td (Phrase, Volume, CPC, Competition, Results, Trend) Bind a Text Input component for keyword lookup. The phrase_this report type returns volume, CPC, competition score, and a 12-month search trend array for any specific keyword.

1// JavaScript transformer — add position change indicators to keyword data
2const rows = parsedKeywords || []; // Use the parsed result from previous transformer
3
4return rows.map(row => {
5  const currentPos = parseInt(row.Po) || 0;
6  const prevPos = parseInt(row.Pp) || 0;
7  const posDiff = parseInt(row.Pd) || 0;
8  const volume = parseInt(row.Nq) || 0;
9
10  // Position change: negative diff means position number decreased = improved ranking
11  const changeDirection = posDiff < 0 ? 'improved'
12    : posDiff > 0 ? 'declined' : 'stable';
13
14  return {
15    keyword: row.Ph || '',
16    current_position: currentPos || 'N/A',
17    previous_position: prevPos || 'N/A',
18    position_change: posDiff !== 0
19      ? (posDiff < 0 ? `▲ ${Math.abs(posDiff)}` : `▼ ${posDiff}`)
20      : '—',
21    change_direction: changeDirection,
22    search_volume: volume.toLocaleString(),
23    cpc: row.Cp ? `$${parseFloat(row.Cp).toFixed(2)}` : 'N/A',
24    keyword_difficulty: row.Kd ? `${row.Kd}%` : 'N/A',
25    ranking_url: row.Ur || 'N/A'
26  };
27}).sort((a, b) => {
28  const aVol = parseInt(a.search_volume.replace(/,/g, '')) || 0;
29  const bVol = parseInt(b.search_volume.replace(/,/g, '')) || 0;
30  return bVol - aVol;
31});

Create queries to retrieve backlink data from SEMrush's Backlinks API. Create a query named getBacklinkOverview: - URL parameters: - type: backlinks_overview - target: {{ textInput_domain.value }} - target_type: root_domain - export_columns: ascore,total,domains_num,urls_num,ips_num,follows_num,nofollows_num,texts_num,images_num This returns the domain's Authority Score (SEMrush's equivalent of Domain Rating), total backlinks, referring domain count, and follow/nofollow distribution. Display these as Stat components at the top of your backlink panel. Create a query named getTopReferringDomains: - type: backlinks_refdomains - target: {{ textInput_domain.value }} - target_type: root_domain - export_columns: domain_ascore,domain,domains_num,backlinks_num,last_seen,first_seen - display_sort: domain_ascore_desc (highest authority domains first) - display_limit: 50 Create a query named getNewAndLostBacklinks: - type: backlinks_tlt (this report shows new and lost backlinks over time) - target: {{ textInput_domain.value }} - target_type: root_domain - export_columns: date,new,lost Bind getNewAndLostBacklinks to a Chart component configured as a grouped bar chart with date on the x-axis and two series: new backlinks (blue bars) and lost backlinks (red bars). This visualization shows link acquisition momentum and helps identify when link losses occur (often corresponding to competitor activity or site changes).

1// JavaScript transformer — format referring domains for display
2const rows = parsedBacklinkData || [];
3
4return rows.map(row => ({
5  domain: row.domain || 'N/A',
6  authority_score: parseInt(row.domain_ascore) || 0,
7  authority_label: parseInt(row.domain_ascore) >= 70 ? 'High'
8    : parseInt(row.domain_ascore) >= 40 ? 'Medium' : 'Low',
9  total_backlinks: parseInt(row.backlinks_num) || 0,
10  first_seen: row.first_seen
11    ? new Date(row.first_seen).toLocaleDateString()
12    : 'N/A',
13  last_seen: row.last_seen
14    ? new Date(row.last_seen).toLocaleDateString()
15    : 'N/A',
16  is_new: row.first_seen
17    ? new Date(row.first_seen) > new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
18    : false
19})).sort((a, b) => b.authority_score - a.authority_score);

Create a competitor comparison panel that shows your domain's SEMrush metrics side by side with up to three competitors. This is the flagship view for weekly SEO reporting. Create a query named getCompetitorOverview that accepts a domain parameter and returns domain_ranks data. You'll trigger this query multiple times — once for your domain and once for each competitor — and merge the results in a JavaScript query. Create a JavaScript query named buildCompetitorTable: In your Retool app, add a TextInput for your domain and three additional TextInputs for competitor domains. Add a 'Run Comparison' button that triggers all four domain_ranks queries simultaneously using Retool's parallel query execution. After all four complete, the buildCompetitorTable JavaScript query merges the results into a single comparison dataset. Bind the result to a Table with columns for domain, organic keywords, estimated traffic, traffic value, paid keywords, and paid traffic. Add a Bar Chart showing organic traffic per domain. For the SEO reporting summary section, add Text components that generate a plain-English summary: 'Your domain ranks for {{ yourMetrics.organic_keywords }} organic keywords with estimated {{ yourMetrics.organic_traffic }} monthly visitors. Top competitor {{ competitorMetrics[0].domain }} ranks for {{ competitorMetrics[0].organic_keywords }} keywords.' This makes the dashboard useful for client reporting without requiring SEO expertise to interpret. For complex multi-domain SEO monitoring pipelines with automated weekly reporting, alert thresholds, and CRM integration, RapidDev's team can help build a comprehensive SEO operations center on Retool.

1// JavaScript query — build competitor comparison table from multiple domain queries
2const domains = [
3  { domain: textInput_domain.value, data: getDomainAnalytics.data },
4  { domain: textInput_competitor1.value, data: getCompetitor1.data },
5  { domain: textInput_competitor2.value, data: getCompetitor2.data },
6  { domain: textInput_competitor3.value, data: getCompetitor3.data }
7].filter(d => d.domain && d.data && d.data.length > 0);
8
9return domains.map(({ domain, data }) => {
10  const row = data[0] || {}; // First (and only) row from domain_ranks report
11  return {
12    domain: row.Domain || domain,
13    organic_keywords: parseInt(row.Or || '0').toLocaleString(),
14    organic_traffic: parseInt(row.Ot || '0').toLocaleString(),
15    traffic_value: row.Oc ? `$${parseInt(row.Oc).toLocaleString()}` : 'N/A',
16    paid_keywords: parseInt(row.Ad || '0').toLocaleString(),
17    paid_traffic: parseInt(row.At || '0').toLocaleString(),
18    semrush_rank: parseInt(row.Rk || '0').toLocaleString(),
19    is_your_domain: domain === textInput_domain.value
20  };
21});