Moz API V1 for Sheets Guide – Help Hub – Moz

If you’ve ever stared at a Google Sheet full of URLs and thought, “Cool. Now I just need link metrics for all of these
before my coffee gets cold,” congratulationsyou’re exactly the kind of person the Moz API + Sheets combo was made for.
The goal of this guide is simple: help you pull Moz link metrics (think Domain Authority, Page Authority, Spam Score,
and link counts) into Google Sheets in a way that’s fast, scalable, and unlikely to turn your spreadsheet into a
haunted house of #N/A errors.

We’ll cover two paths:

• No-code: Use Moz API for Sheets (a Google Sheets add-on) to pull data without writing scripts.
• Power-user mode: Use the Moz Links API directly (with Apps Script or an API connector) when you want full control.

What “Moz API V1 for Sheets” really means (and why you should care)

“V1 for Sheets” is often used to describe the spreadsheet-friendly workflow: authenticate once, then request link metrics
repeatedly for targets (domains or URLs) and land the results in tidy columns. The important part isn’t the labelit’s
the repeatable process:

1. Pick your targets (URLs/domains) in Sheets
2. Choose an endpoint (URL Metrics, Top Pages, Links, etc.)
3. Send a request (usually POST with JSON)
4. Receive JSON, flatten it into columns, and build insights

The Moz Links API endpoints for link data are organized under a base URL, and each endpoint returns rows of JSON objects.
Those “rows” matter because Moz’s pricing/limits are based on rows consumed. Translation: your spreadsheet can be cheap
and cheerfulor it can silently eat your monthly quota like it’s an all-you-can-eat buffet.

Quick glossary: the Moz API terms you’ll see in Sheets

Targets

A “target” is what you’re asking about: a root domain (example.com), a subdomain (blog.example.com), or a page URL
(https://example.com/page).

Scope

Scope tells the API how wide to look. For example, some endpoints let you specify whether you mean a page vs. an entire
root domain. (This is a fancy way of saying: “Be specific or the internet will misunderstand you.”)

Rows consumed

Moz API usage is measured in “rows,” where a row is typically a JSON object returned by an endpointlike one URL’s metrics,
one link, or one anchor-text record. Some endpoints and options are weighted, meaning they can consume more than one row
per returned record depending on what you request.

Option A: No-code setup with “Moz API for Sheets” (fastest path)

If you want the simplest workflow, start with Moz’s Sheets add-on. It’s designed for exactly this: pull link metrics into
Sheets without writing code, and it supports both free and paid Moz API plans.

Step 1: Install the add-on

1. Open Google Sheets
2. Go to Extensions → Add-ons / Get add-ons
3. Search for Moz API for Sheets and install

Step 2: Get your Moz API access

You’ll need Moz API credentials. Moz’s free plan is useful for testing and small jobs, but it’s rate-limited and capped
on monthly rowsso it’s best treated like a sample platter, not your entire meal prep.

Step 3: Connect the add-on to Moz

Most add-ons follow the same pattern: open the add-on sidebar, paste in your token/credentials, choose an endpoint/metric,
select a target range (like column A), then run the request into a destination sheet.

Once connected, you can build a clean workflow:

• Input tab: your list of URLs/domains
• Output tab: returned metrics and link data
• Analysis tab: pivots, filters, and “what do we do with this?” decisions

Option B: Use Moz Links API directly inside Sheets (maximum control)

If you want to customize endpoints, batch requests, monitor usage precisely, or integrate multiple APIs into one file,
use the API directly. You can do this with:

• An API connector add-on (great for non-developers who still want control)
• Google Apps Script (great when you want custom functions, caching, and automation)

Know the basics: base URL, endpoints, and request style

Moz link data endpoints are organized under a base URL, and requests generally use POST with JSON bodies. Some common
endpoints you’ll see in SEO workflows:

• URL Metrics (Authority + link metrics for targets)
• Top Pages (top pages for a domain)
• Links (link lists)
• Anchor Text (anchor text distributions)
• Link Intersect (competitors have links you don’t)

Authentication: token header vs. Basic credentials

Depending on your tool, you’ll authenticate in one of two spreadsheet-friendly ways:

• Token header: add your token in a request header (often shown as x-moz-token).
  This is common in tools like Postman and some custom setups.
• Basic auth: encode credentials in the format access_id:secret_key (Base64),
  then send as Authorization: Basic ....

In plain English: whichever route you use, treat your credentials like your house keys. Don’t paste them into a public
template. Don’t share the sheet with “anyone with the link.” And definitely don’t email them to yourself in 2013 Yahoo
Mail. (That mailbox is a museum now.)

Your first practical pull: URL Metrics in a spreadsheet-friendly way

URL Metrics is usually where people start because it lets you answer immediate questions:

• Which domains look strongest (Authority)?
• Which pages are likely to be valuable targets?
• Which prospects are suspicious (Spam Score)?

Example request body

A common pattern is sending a list of targets:

In an API connector, you’d typically set:

• Method: POST
• Endpoint: something like /url_metrics
• Body: JSON with your targets
• Auth: token header or Basic

Spreadsheet tip: batch targets to reduce calls

A rookie mistake is calling the API once per row. That works until your sheet has 3,000 rows and you discover what
“rate limit” feels like in your soul. Instead, send targets in batches (for example, 25–200 at a time depending on the
endpoint and tool), then write results back in one output block.

Second practical pull: Top Pages for quick competitor intelligence

The Top Pages endpoint is perfect for competitor research and content planning because it answers:
“What pages appear strongest on this domain?”

Example request body

In Sheets, this becomes a repeatable template:

1. Put competitor domains in column A
2. Run Top Pages for each domain (preferably in batches or scheduled runs)
3. Normalize URLs and group by folder/topic
4. Compare against your own content to spot gaps

Monitoring usage: how to avoid “surprise, you’re out of rows”

Moz usage is based on rows returned, and some endpoints are weighted. You can monitor usage in the Moz API dashboard,
and there’s also an API endpoint for usage data. That means you can build a “gas gauge” tab in Sheets that tells you:
“You’ve used X rows this monthmaybe don’t run Link Intersect on 400 competitors today.”

Why weighted endpoints matter

Endpoints like Link Intersect and Link Status can consume more rows than you expect. Even URL Metrics can become “heavier”
when you request historical data or distributions. The safe approach is to:

• Start with the minimum fields needed for a decision
• Test with a small batch
• Scale only after you know the row cost

Troubleshooting: common Sheets + Moz API failures (and how to fix them)

401 Not Authorized

• Likely cause: token/credentials wrong, expired, or copied with extra spaces
• Fix: re-paste credentials, regenerate token if needed, and confirm the request headers

429 Too Many Requests

• Likely cause: you’re hitting plan limits or firing too many requests too quickly
• Fix: slow down, batch targets, and add backoff (pause/retry) in scripts or connectors

400 Bad Request

• Likely cause: invalid JSON, wrong parameter name, unsupported scope, or malformed URL
• Fix: validate JSON, test requests in a smaller tool (or one-row sample), and confirm endpoint requirements

“URL must be ASCII only” (yes, this is a real thing)

If you send non-ASCII characters (certain Unicode characters in URLs), some tools will complain. The fix is usually to
normalize/encode URLs before sending them, and to avoid copying “pretty” URLs that contain hidden characters.

Apps Script approach: when you want custom functions and automation

For advanced teams, Apps Script turns Sheets into a lightweight SEO dashboard. The key is to avoid building a sheet that
recalculates 5,000 API calls every time someone sneezes near the keyboard.

Best-practice pattern (pseudo-workflow)

• Do not call the API once per cell using volatile custom functions for large datasets.
• Do use a menu button (“Run Moz Pull”) that fetches in batches and writes results as values.
• Do cache results for a short time (hours/days) so you aren’t re-buying the same data repeatedly.

Classic “old-school V1” signing and why it still shows up in Sheets

Before modern token-based workflows became common, many Moz API integrations used signed requests (with an access ID,
expiration timestamp, and signature). You’ll still see this approach in olderbut still educationalSheets scripts,
especially in SEO tutorials that predate today’s add-ons. If you inherit one of these scripts, don’t panic:
the logic is usually fine, but you may want to modernize authentication and batching.

Smart ways to use Moz metrics in real SEO decisions

Use Authority as a comparison tool, not a crystal ball

Domain Authority and Page Authority are best used to compare sites/pages within a similar context. They’re excellent for
prioritization (“Which prospects look strongest?”), but not for guarantees (“If we get this link, we will rank #1 by Tuesday”).

Build a “Prospecting Score” column that blends metrics

A practical spreadsheet trick: blend Moz metrics with your own qualifiers. Example:

• Authority metrics (DA/PA)
• Relevance tag (manual or keyword-based)
• Link type likelihood (editorial vs. directory)
• Risk flag (Spam Score or suspicious patterns)

That turns “a pile of numbers” into “a prioritized outreach plan,” which is a much more profitable spreadsheet species.

Conclusion

The Moz API + Google Sheets workflow is one of the fastest ways to turn link metrics into action. If you want speed,
install the Moz API for Sheets add-on and pull metrics without code. If you want control, use an API connector or Apps
Script to batch targets, monitor row usage, and build repeatable competitor and prospecting dashboards.

The real win isn’t just fetching metricsit’s building a spreadsheet that answers decisions quickly:
“Which sites are worth outreach?” “Which competitor pages are strongest?” “Where do we have link gaps?” When your sheet
can answer those in minutes, you’ve basically built an SEO sidekick that doesn’t need lunch breaks.

Experience Addendum: of Real-World Moz API + Sheets Lessons

The first time I wired Moz metrics into a Google Sheet, I did what many optimistic people do: I assumed spreadsheets were
infinitely patient and APIs were infinitely forgiving. I pasted 4,000 URLs into column A, wrote a plan in my head that
could only be described as “I will simply fetch all the data,” and then watched everything politely fall apart.

Lesson one: rate limits are not personal, but they feel personal. When you trigger a 429, it’s not Moz
calling you out as a villainit’s the API asking you to breathe, batch, and stop sending requests like you’re trying to
win a carnival game. Once I switched to batching (even 50–200 targets per request, depending on the endpoint) the entire
workflow went from “chaos spreadsheet” to “calm dashboard.”

Lesson two: custom functions are a trap if you scale them carelessly. A custom function that fetches API
data can be wonderful for one-off checks. But if it recalculates across thousands of rows whenever someone edits a cell,
you’ve effectively built a tiny machine that repeatedly lights your quota on fire. The fix was simple: I moved from
cell-by-cell functions to a menu-driven script (“Run Moz Pull”) that writes results as values. Suddenly the sheet stopped
behaving like a caffeinated squirrel.

Lesson three: “rows consumed” is the metric that actually matters. I used to track requests. Then I
realized a single request can return a lot of rowsand certain endpoints or options can be weighted. That’s when I started
keeping a “Usage” tab. It’s not glamorous, but neither is explaining to a teammate why the dashboard stopped working on the
19th of the month because someone ran Link Intersect on every domain in a competitor list.

Lesson four: Authority metrics are most useful when paired with context. I’ve seen people treat DA/PA like
destiny. In practice, I got the best results when I combined Moz metrics with relevance, intent, and basic common sense.
A high-authority site that’s irrelevant to your niche is like an expensive billboard in the wrong city. Meanwhile, a
mid-authority site that’s deeply relevant can outperform expectationsespecially when it actually sends qualified traffic.

Lesson five: build a “decision sheet,” not a “data hoarding sheet”. The goal isn’t to collect every metric
Moz offers; it’s to answer questions quickly. I now start every sheet with a small checklist:
“What decision will this metric influence?” and “How often do we need to refresh it?” That alone cut my API usage, improved
team trust in the numbers, and made the spreadsheet feel like a tool instead of a landfill of JSON.

The funny part is: once the process is clean, it feels almost boring. Install add-on or connector. Authenticate. Batch.
Pull. Analyze. Repeat. And in SEO, “boring and repeatable” is usually another way of saying “profitable.”