Website authority checker: how to track domain authority signals at scale

What authority scores measure

A website authority checker estimates how likely a domain or page is to rank in search results, on a scale from 0 to 100. The best-known versions are Moz's Domain Authority and Page Authority, Semrush's Authority Score and Ahrefs' Domain Rating. They are different formulas with different data, so the same site gets a different number in each - and none of them is a Google ranking factor. Google doesn't publish an authority score of its own.

What the scores have in common is that they lean heavily on a site's backlink profile: how many other sites link to it, and how strong those sites are. That is why they are useful for comparison - a site with a much weaker score than its competitors usually has a weaker link profile too.

Why you track your own signals

The scores come from each vendor's private backlink index. They are not written into the pages themselves, so UnblockingAPI - which fetches public pages and returns what is on them - can't return a Domain Authority or Authority Score for a URL. Anyone who claims a fetch API can is selling something else.

Signals you can collect from public pages

• — On-page basics. Title, meta description, canonical URL, headings and whether the page is indexable.
• — Structured data. JSON-LD blocks and the schema types a page declares.
• — Link structure. Internal and external links on a page, and which domains a site links out to.
• — Rankings. Where a domain appears for a set of keywords, captured from result pages - see SEO rank tracking and search result page scraping.
• — Tracking and metrics tags. Whether Google Analytics, Tag Manager or Search Console verification is present - covered below.

First request

Many sites build their pages with JavaScript, so fetch with rendering on to get the page as a visitor sees it. The response field of the JSON reply holds the HTML. See the API documentation for the full parameter list.

curl \
  -H "X-Api-Key: YOUR_API_KEY" \
  "https://api.unblockingapi.com/unblock?url=https://example.com/&render=true"

Why rendering matters is covered in how to scrape JavaScript-rendered pages.

Collect page signals

This Node.js example fetches a page and turns it into one flat record you can store. It uses Cheerio to parse the returned HTML.

import * as cheerio from "cheerio";

async function fetchHtml(url) {
  const res = await fetch(
    `https://api.unblockingapi.com/unblock?url=${encodeURIComponent(url)}&render=true`,
    { headers: { "X-Api-Key": process.env.UNBLOCKINGAPI_KEY } }
  );
  const data = await res.json();
  return data.response;
}

function hostOf(href) {
  try { return new URL(href).hostname; } catch { return null; }
}

export async function pageSignals(url) {
  const html = await fetchHtml(url);
  const $ = cheerio.load(html);
  const host = new URL(url).hostname;

  const hrefs = $("a[href]").map((_, a) => $(a).attr("href")).get();
  const external = hrefs.filter((h) => /^https?:/.test(h) && hostOf(h) !== host);

  return {
    url,
    checkedAt: new Date().toISOString(),
    title: $("title").first().text().trim(),
    description: $('meta[name="description"]').attr("content") ?? null,
    canonical: $('link[rel="canonical"]').attr("href") ?? null,
    noindex: /noindex/i.test($('meta[name="robots"]').attr("content") ?? ""),
    schemaBlocks: $('script[type="application/ld+json"]').length,
    links: hrefs.length,
    externalLinks: external.length,
  };
}

Run it over a list of URLs - your own pages, a competitor's key pages, or the top results for a keyword - and you have a dataset to compare, instead of one lookup at a time.

Analytics and tag checker

A common companion check is whether a page has Google Analytics, Tag Manager or Search Console verification in place. Fetch the rendered page and look for the identifiers:

function uniq(matches) {
  return [...new Set(matches ?? [])];
}

export function trackingTags(html) {
  return {
    ga4: uniq(html.match(/\bG-[A-Z0-9]{6,12}\b/g)),
    tagManager: uniq(html.match(/\bGTM-[A-Z0-9]{4,8}\b/g)),
    legacyUniversalAnalytics: uniq(html.match(/\bUA-\d{4,10}-\d{1,4}\b/g)),
    gtagScript: html.includes("googletagmanager.com/gtag/js"),
    searchConsoleMeta: /<meta[^>]+name=["']google-site-verification["']/i.test(html),
  };
}

A few things to keep in mind when reading the result:

• — Consent banners. Many sites load analytics only after a visitor accepts cookies, so no tag in a fetch doesn't always mean no tag for real users.
• — Tag Manager hides tags. If a container is present, the analytics tag may live inside it rather than in the page source.
• — Legacy IDs. Universal Analytics (UA-) tags stopped collecting data in 2023 - finding one means the site hasn't migrated to GA4.
• — Pattern matches can be false positives. Treat a hit as a lead to confirm, not proof.

Authority history over time

A domain authority history checker is simply repeated measurement. Run the collector on a schedule - weekly is plenty for most sites - and store each record with its timestamp. Then you can chart changes: new schema blocks added, canonical tags fixed, outbound links growing, rankings moving.

For a worked pipeline around scheduling, storage and change alerts, see the competitor research use case.

What is a good domain authority score?

There is no universal threshold. The scores are logarithmic and meant to be read relative to competitors: moving from 20 to 30 is much easier than moving from 70 to 80. A good score is one that is at or above the sites currently ranking for the keywords you want. Check the sites in your own results rather than chasing a fixed number.

Increasing domain authority

Because the scores follow backlinks, the lasting way to raise them is to earn links from relevant, credible sites - original data, useful tools and guides people cite. The on-page signals above won't move a score by themselves, but they do show whether the basics are in place: canonical tags, structured data, a sensible internal link structure.

Tracking those basics across your pages and your competitors' tells you where the gaps are before you spend on outreach.

Prefer no code?

You can collect fields like titles, headings and link lists without writing a parser: open the page in the visual editor, tap what you want and save it as a reusable template that returns clean JSON on every call. Ready-made options live in the templates library.

Responsible use

Frequently asked questions