How to Integrate Retool with Moz

Moz API credentials are available through the Moz Pro account portal. Log into your Moz account at moz.com and navigate to Products → Moz Pro → API (or go directly to moz.com/products/pro/api). You will see your API Credentials section displaying your Access ID and Secret Key. The Access ID is a string in the format 'mozscape-[random characters]'. The Secret Key is a longer alphanumeric string. Both are needed for Basic Auth — the Access ID is the username and the Secret Key is the password. Note your API credit allowance shown on the same page. The Moz API uses a credit system where batch URL Metrics queries consume 1 row per URL requested. Standard plan includes limited credits; higher plans include more. For a dashboard that queries DA for 20 competitor domains daily, calculate the monthly credit consumption to ensure your plan supports it. The Moz Links API v2 base URL is: https://lsapi.seomoz.com/v2/ Key endpoints you will use: - URL Metrics (batch): POST /url_metrics — returns DA, PA, Spam Score for up to 50 URLs per request - Anchor Text: POST /anchor_text — returns top anchors for a domain - Links: POST /links — returns link details for a domain - Linking Domains: POST /linking_domains — returns domain-level link data The POST URL Metrics endpoint is the most efficient for dashboard use — it accepts an array of URLs and returns metrics for all in a single request, consuming one credit per URL.

Navigate to the Resources tab in Retool and click Add Resource. Select REST API from the resource type list. Configure the resource: - Name: 'Moz Links API' - Base URL: https://lsapi.seomoz.com/v2 For authentication, select Basic Auth from the Auth dropdown: - Username: your Moz API Access ID (the full string including 'mozscape-' prefix) - Password: your Moz API Secret Key Add default headers that will be sent with every request: - Key: Content-Type, Value: application/json - Key: Accept, Value: application/json Click Save Changes. Store the credentials in Retool Configuration Variables (Settings → Configuration Variables) named MOZ_ACCESS_ID and MOZ_SECRET_KEY, both marked as secret. Update the resource's Basic Auth fields to reference these variables: Username: {{ retoolContext.configVars.MOZ_ACCESS_ID }}, Password: {{ retoolContext.configVars.MOZ_SECRET_KEY }}. Verify the resource by creating a test query: - Method: POST - Path: /url_metrics - Body: { "targets": ["moz.com"], "metrics": ["domain_authority", "page_authority", "spam_score"] } Run the query. A successful response returns a results array with one entry for moz.com, showing its Domain Authority (currently in the 90+ range), Page Authority, and Spam Score. If you receive a 401 error, verify the Access ID and Secret Key are correctly configured.

The Moz API's /url_metrics endpoint accepts an array of URLs and returns metrics for all of them in a single request, making it the efficient choice for dashboard use. Build a query that accepts a user-entered list of domains and fetches all their metrics simultaneously. Create a new query using the Moz Links API resource: - Method: POST - Path: /url_metrics - Body type: Raw JSON - Body: a JSON object with a 'targets' array and a 'metrics' array specifying which metrics to return For the 'targets' array, reference a state variable or text area input that contains the list of domains. Parse newline-separated input into an array using a JavaScript expression in the body. The 'metrics' array specifies which Moz metrics to return. Key metrics to request: domain_authority, page_authority, spam_score, links (total links), root_domains_to_root_domain (linking unique domains), external_links. Including only the metrics you need reduces response size and credit consumption. The response returns a results array where each item corresponds to one target URL, containing the requested metric values. Map the results back to the original URL list using the array index. Write a JavaScript transformer that maps the results to a display-ready array with formatted metric values. Bind to a Table component sorted by Domain Authority descending.

1// POST /url_metrics request body
2// References a TextArea component where users enter domains (one per line)
3{
4  "targets": {{ domainTextArea.value.split('\n').map(d => d.trim()).filter(Boolean).slice(0, 50) }},
5  "metrics": [
6    "domain_authority",
7    "page_authority",
8    "spam_score",
9    "root_domains_to_root_domain",
10    "external_links"
11  ]
12}
13
14// ---
15// JavaScript transformer for Moz URL Metrics response
16const results = data?.results || [];
17const targets = domainTextArea.value
18  .split('\n')
19  .map(d => d.trim())
20  .filter(Boolean)
21  .slice(0, 50);
22
23return results.map((result, index) => ({
24  domain: targets[index] || result.url || 'Unknown',
25  domain_authority: result.domain_authority ?? 'N/A',
26  page_authority: result.page_authority ?? 'N/A',
27  spam_score: result.spam_score ?? 0,
28  linking_domains: result.root_domains_to_root_domain ?? 0,
29  total_links: result.external_links ?? 0,
30  spam_risk: (result.spam_score || 0) > 7 ? 'High'
31    : (result.spam_score || 0) > 4 ? 'Medium'
32    : 'Low',
33  quality_tier: (result.domain_authority || 0) >= 50 ? 'Premium'
34    : (result.domain_authority || 0) >= 30 ? 'Good'
35    : (result.domain_authority || 0) >= 10 ? 'Marginal'
36    : 'Poor'
37})).sort((a, b) => (b.domain_authority || 0) - (a.domain_authority || 0));

To show DA/PA trends rather than just point-in-time values, build a historical tracking system using Retool Database or a connected PostgreSQL table. Each time the dashboard is refreshed, store the current Moz metrics alongside a timestamp — this builds a time series that shows whether domains are gaining or losing authority. Create a Retool Database table (from the Resources panel → Add Resource → Retool Database) with columns: domain (text), domain_authority (integer), page_authority (integer), spam_score (integer), snapshot_date (date), and notes (text, optional). After your Moz metrics query runs, add a button labeled 'Save Snapshot' that triggers a write query: INSERT INTO da_snapshots (domain, domain_authority, page_authority, spam_score, snapshot_date) VALUES using the current Moz results data. Use Retool's GUI mode for the insert query to prevent SQL injection. Create a second query that reads historical snapshots for the selected domains from the database. Write a transformer that computes month-over-month DA change for each domain by comparing the latest snapshot to the snapshot from 30 days ago. Add a Line Chart component showing DA trends over time for selected domains. The chart's X-axis is the snapshot_date and Y-axis is domain_authority, with one series per domain. This converts Moz's point-in-time API data into trend intelligence that shows which competitors are building authority and which are declining. For automated daily snapshots without manual button clicks, set up a Retool Workflow on a schedule that queries Moz for a predefined list of domains and writes the results to the snapshots table automatically.

1// JavaScript transformer to compute DA change from historical snapshots
2// Combines current Moz data with historical snapshots from database
3
4const currentData = mozMetricsQuery.data || []; // transformed results array
5const historicalData = historicalSnapshotsQuery.data || []; // database results
6
7return currentData.map(current => {
8  // Find the snapshot from approximately 30 days ago for this domain
9  const thirtyDaysAgo = new Date();
10  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
11
12  const historicalEntry = historicalData
13    .filter(h =>
14      h.domain === current.domain &&
15      new Date(h.snapshot_date) <= thirtyDaysAgo
16    )
17    .sort((a, b) => new Date(b.snapshot_date) - new Date(a.snapshot_date))[0];
18
19  const prevDA = historicalEntry?.domain_authority ?? null;
20  const daChange = (prevDA !== null && current.domain_authority !== 'N/A')
21    ? current.domain_authority - prevDA
22    : null;
23
24  return {
25    ...current,
26    prev_da: prevDA !== null ? prevDA : 'No history',
27    da_change: daChange !== null ? daChange : 'N/A',
28    da_trend: daChange === null ? '—'
29      : daChange > 0 ? `+${daChange} ▲`
30      : daChange < 0 ? `${daChange} ▼`
31      : 'No change'
32  };
33});

Extend the SEO dashboard with a linking domains panel that queries Moz for the top domains linking to a specific URL. This gives SEO teams visibility into where a domain's link equity is coming from, informing link acquisition strategy and competitor analysis. Create a query using the Moz Links API resource: - Method: POST - Path: /linking_domains - Body: JSON object specifying the target domain, metric fields to return, and pagination The /linking_domains endpoint accepts a single target and returns a list of domains that link to it, along with each linking domain's DA and the number of links from that domain. This is useful for understanding a competitor's link profile. Set the query to run 'Only when' a domain is selected from the main metrics Table ({{ domainTable.selectedRow !== null }}). This avoids running the linking domains query on every domain load — only run it when an analyst specifically wants to investigate a particular domain's link profile. Write a transformer that sorts linking domains by their own DA score (highest first, as these are the most valuable links), formats the domain counts, and flags self-referential links (when the linking domain is the same as or a subdomain of the target). Display the results in a detail panel or slide-out drawer component. This combination — the main DA tracking table plus the linking domains drill-down — gives SEO teams both the portfolio overview and the detailed backlink intelligence they need without leaving the Retool dashboard.

1// POST /linking_domains request body
2// Runs when a domain is selected from the main metrics table
3{
4  "target": "{{ domainTable.selectedRow?.domain || 'moz.com' }}",
5  "target_scope": "domain",
6  "limit": 50,
7  "metrics": ["domain_authority", "spam_score", "links_to_target"],
8  "sort": "domain_authority_desc"
9}
10
11// ---
12// JavaScript transformer for linking domains response
13const results = data?.results || [];
14const targetDomain = domainTable.selectedRow?.domain || '';
15
16return results.map(link => ({
17  linking_domain: link.root_domain || link.url || 'Unknown',
18  linking_da: link.domain_authority ?? 0,
19  links_to_target: link.links_to_target ?? 0,
20  spam_score: link.spam_score ?? 0,
21  is_self_referential: targetDomain
22    ? (link.root_domain || '').includes(targetDomain.replace(/^www\./, ''))
23    : false,
24  quality: (link.domain_authority || 0) >= 50 ? 'High DA'
25    : (link.domain_authority || 0) >= 30 ? 'Medium DA'
26    : 'Low DA'
27})).sort((a, b) => b.linking_da - a.linking_da);