Six nodes, one credential and about ten minutes. You end up with a Sheet that fills itself with referring-domain counts for every site on your list.
Deeplinkify research team ·
Before you open the canvas
A Google account to sign in and copy your sk_live_... key from the dashboard.
A Google Sheet with a header row and one domain per line in column A.
An n8n credential of type Header Auth named Deeplinkify, with Authorization as the name and Bearer sk_live_... as the value.
A test domain you already know the answer for, so you can sanity-check the first response.
The six nodes
1
Schedule Trigger
Weekly is plenty. The link index refreshes about once a month, so a daily trigger mostly re-reads the same numbers.
2
Google Sheets: Get Row(s)
Read column A. Each item now carries one domain. Trim whitespace in the next node if your list was pasted from an email.
3
Loop Over Items
Set the batch size to 1 for refdomains pulls. A loop of 200 domains then sends 200 polite requests instead of a burst.
4
HTTP Request
GET https://deeplinkify.com/api.php, with action=overview, q from the current item, and the Header Auth credential. overview is free, so test it here first.
5
Edit Fields
Pick the fields you want from the response, add checked_at with {{ $now }} and keep _credits so the spend is visible.
6
Google Sheets: Append Row
Write the domain, your picked fields and the timestamp to a second tab. Keep the input tab untouched so reruns are safe.
The HTTP Request node, spelled out
These are the values to type into the node. Parameter names come straight from the API; check one real response in the node's output panel before you map fields.
text
Method: GET
URL: https://deeplinkify.com/api.php
Authentication: Generic Credential Type -> Header Auth -> Deeplinkify
Send Query: on
action overview (free) or refdomains (2 credits)
q {{ $json.domain }}
per 100 (refdomains only)
Options:
Timeout 30000
Retry On Fail on, 2 tries, wait 2000 ms
On Error Continue (using error output)
Mapping the response without guessing
Run it once. Look at the output.
Pinning is the trick. Open the HTTP Request node, execute it on a single domain, and switch the output panel to JSON view. Pin that data so later nodes can be built against a fixed sample. Every authenticated response includes ok and _credits, which are the two keys you can rely on blindly; for the rest, trust what the pinned sample shows.
If you copy this workflow for a second client, duplicate it rather than editing the first, and give each copy its own key so the spend is separable. The Make version uses the same habit.
Why the loop and the retry matter
An unthrottled n8n run can fire a request per item at machine speed. That is fine for a handful of domains and rude for a few thousand.
We publish no requests-per-second ceiling, so pace it yourself: a Wait node of one or two seconds inside the loop is cheap insurance, and Retry On Fail covers the odd network blip without you babysitting the execution list.
Do not retry on a 402. It means the balance is empty, and ten retries just produce ten identical failures. Route the error output to a Slack or email node instead and top up before the next run. The error runbook has the exact expression for that branch.
One more detail from 2025 onwards: n8n's Code node and expressions changed between major versions, so if a snippet in a forum thread fails, check which version it was written for before blaming the API.
What the run costs
Hypothetical list sizes, weekly schedule, 1 credit = $0.0001. Your n8n plan bills executions separately.
Sites on the list
Action
Credits per run
Cost per year
50
overview
0
$0
50
refdomains
100
$0.52
500
refdomains
1,000
$5.20
500
refdomains + anchors
2,000
$10.40
Where this stops
n8n is the right host while the list is human-sized
A few hundred domains and a weekly schedule fit n8n well. If you need one rating per row for 20,000 rows, skip the loop and use one bulk_dr call instead, as shown in the outreach list recipe.
Under 2,000 domains for ratings only: bulk_dr, one credit.
Per-site link lists: loop with a wait.
Production use: run on a queue-mode instance and watch the execution list.