How to Build Your Own Rank Tracker (Bing and DuckDuckGo)
Rank trackers disagree with each other and with your own browser. Here's why (market, region and device), and a tested rank tracker for Bing and DuckDuckGo that records what it actually checked.
Short answer: call a rank-check endpoint with a query, your domain and a fixed locale, store the position with the date, and repeat on a schedule. FetchLayer’s Bing and DuckDuckGo rank checks scan up to 200 positions in one request, at $1.99 per 1,000 checks, and the first 30 requests are free. To check a single keyword by hand, the free Bing SERP checker does it in the browser.
A thread on r/seogrowth captures a complaint that shows up constantly: rank trackers showing results that don’t match what a real person sees in a live browser search — sites sitting at position #2 for a real visitor, completely absent from the top 10 across “every automated data source” tested. The tools aren’t broken. They’re usually just checking the wrong location, the wrong device, or the wrong country, and reporting a confident number anyway.
Rankings are not one number. Bing and DuckDuckGo both localize results by market or region, Bing also by device, and a rank check that doesn’t pin those down is measuring something different every time it runs, which looks exactly like “the rank tracker is wrong” from the outside.
This guide builds a tracker for Bing and DuckDuckGo that controls for that. For Google, your own site’s average position per query is in Google Search Console.
Pin down what “rank” means before you check it
Every rank check is a query, a target, and the locale the check runs under. Get the locale wrong and the number is meaningless even when the request succeeds. The two engines don’t share a vocabulary for it:
| Engine | Locale parameter | Example | Also |
|---|---|---|---|
| Bing | market | en-US | country when it should differ from the market; device: desktop or mobile |
| DuckDuckGo | region | us-en | — |
Map your one canonical setting (“US, English, desktop”) to each engine’s own parameter rather than assuming one string works everywhere.
Why last week’s number and this week’s don’t match
If you change market, region or device between runs, you’re no longer tracking the same thing: you’re sampling a different results page each time and calling the difference a ranking change. Keep every locale parameter fixed for a tracked (query, target) pair, and change it deliberately, as a new tracked series, when you want to check a different market. Bing ranks slightly differently on desktop and mobile, so the device is part of the series too.
A working tracker
This script checks each query on both engines, appends the result to a JSON history file, and is safe to run from cron:
import { readFile, writeFile } from 'node:fs/promises';
const API_KEY = process.env.FETCHLAYER_API_KEY;
const HISTORY = './rank-history.json';
const TARGET = 'fetchlayer.dev';
const QUERIES = ['reddit api alternative', 'app store reviews api'];
// One canonical setting ("US, English, desktop"), written in each engine's own words
const ENGINES = {
bing: { market: 'en-US', device: 'desktop' },
duckduckgo: { region: 'us-en' },
};
async function rankCheck(engine, query) {
const res = await fetch(`https://api.fetchlayer.dev/${engine}/rank-check`, {
method: 'POST',
headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
body: JSON.stringify({ query, target: TARGET, depth: 100, ...ENGINES[engine] }),
});
const body = await res.json();
if (!res.ok) throw new Error(`${engine} "${query}": ${body.code ?? res.status} ${body.error ?? ''}`);
return body;
}
let history = [];
try {
history = JSON.parse(await readFile(HISTORY, 'utf8'));
} catch {}
const date = new Date().toISOString().slice(0, 10);
for (const query of QUERIES) {
for (const engine of Object.keys(ENGINES)) {
let result = await rankCheck(engine, query);
// A short scan without endOfResults is "unknown", not "not ranking": retry once
const partial = (r) => !r.found && !r.endOfResults && r.depthScanned < r.depth;
if (partial(result)) result = await rankCheck(engine, query);
const status = result.found ? 'ranked' : partial(result) ? 'unknown' : 'not ranked';
// null, not 0, when there is no position
const position = result.found ? result.position : null;
history.push({ date, engine, query, status, position, depthScanned: result.depthScanned, url: result.matches?.[0]?.url ?? null });
console.log(`${engine.padEnd(10)} ${query.padEnd(24)} ${position ?? status} (scanned ${result.depthScanned})`);
}
}
await writeFile(HISTORY, JSON.stringify(history, null, 2));Run it with bun tracker.mjs or node tracker.mjs (Node 18 or later). Our run on 14 November 2026:
bing reddit api alternative 3 (scanned 10)
duckduckgo reddit api alternative 2 (scanned 10)
bing app store reviews api not ranked (scanned 100)
duckduckgo app store reviews api 4 (scanned 10)“Not ranked (scanned 100)” is a confirmed absence: every one of the 100 positions was read.
Two details in it matter more than they look:
- “Not found” and “not checked” are different. When a check can’t read the full depth, the response says so in
notesanddepthScannedis lower thandepth, withoutendOfResults. That isn’t a confirmed absence, so the script retries once and recordsunknownrather than a drop out of the top 100. Charting it as “not ranking” would invent a ranking loss. - A check stops at the first page with a match. That’s why a target found at position 3 shows “scanned 10”. To see every page of yours that ranks, use
allMatches(below).
Plot position per engine over weeks. A gap between Bing and DuckDuckGo for the same query isn’t a bug in the tracker: the engines genuinely disagree, which is worth knowing on its own.
allMatches: catching more than the first hit
By default, a rank check stops after the first result page that contains your target. If your site has more than one ranking page for a query, the default only tells you about the best one. allMatches: true scans the full depth and reports every match:
body: JSON.stringify({ query, target: TARGET, depth: 50, allMatches: true })On DuckDuckGo for “reddit api alternative” at depth 50, that returned three of our pages:
position 3 page 1 /blog/reddit-api-alternatives
position 35 page 3 /blog/reddit-api-closed-2026
position 43 page 4 /reddit-scraperRead matches (each with its position, page, url and title) rather than the top-level position, which only reports the best match. This is how you catch keyword cannibalization, two of your own pages competing for one query, which a single-position check can’t see.
includeSubdomains, and why the default matters
When you target a bare domain (example.com), both engines count subdomains (blog.example.com) as the site by default. To track your root domain separately from a blog or docs subdomain, target the exact host and set includeSubdomains: false. Otherwise a blog post ranking well can hide your root domain not ranking at all for the same query.
Practical notes
- Depth costs the same at any value. A rank check is one request whether it scans 10 positions or 200 (
depthup to 200, or-1for the maximum), so there’s no reason to default to a shallow scan and miss a page at position 40. Result pages examined are reported inserpPagesFetchedand never billed. - DuckDuckGo still shows a site for a query that names it outright, even with
safeSearch: strict. Don’t read a missing result as a block; check the query first. - A
targetcan be a domain or a URL with a path. A bare domain matches the site and its subdomains (unless you turn that off). A URL with a path only matches pages under that path, which is the one to use when tracking a single landing page. - What it costs: 50 keywords on both engines, checked daily, is about 3,000 requests a month: roughly $5.97 pay-as-you-go, or within the $25 Starter plan’s 15,000 requests (pricing).
Next Steps
- Free Bing SERP checker: check one keyword’s Bing results in the browser
- Bing Search API · DuckDuckGo Search API · SERP API
- Ranking is half the picture: what Bing’s AI answer says about you and what Duck.ai’s models say
- Get a free API key: 30 free requests, no credit card