# Link Gap Finder & Backlink Gap Analysis (`datapulsehq/link-gap-finder`) Actor Find the sites that link to your competitors but not to you, one row per site. Up to 20 competitors, with domain rank, spam risk and the strongest link URL. Service domains and spammy sites removed. - **URL**: https://apify.com/datapulsehq/link-gap-finder.md - **Developed by:** [Data Pulse](https://apify.com/datapulsehq) (community) - **Categories:** SEO tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.20 / 1,000 prospects This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Link Gap Finder & Backlink Gap Analysis Find the sites that link to your competitors but not to you. Give your domain and up to 20 competitor domains, and the Actor returns a list of link prospects, one row per site: each site that links to at least the number of competitors you choose and has no link to your site, with how many competitors it links to, its domain rank and spam risk, the links it gives each competitor and, for the top 50, the URL and type of its strongest link. Service domains are removed before you see the list: newsletter and email infrastructure, CDNs, URL shorteners, ad and redirect domains, and caches and archives. Prospects with a spam risk above 40 are left out by default. A site that links to three of your competitors writes about your topic and already links out to sites like yours. That makes it a better outreach prospect than a random site with a high rank, and this list is the usual starting point for link building and for checking where a competitor gets its links. ### How the backlink gap analysis works The link index answers one question very well: which sites link to all of these targets and to none of those. For "at least 2 of 3 competitors" the Actor asks that question once for every pair of competitors, always with your domain excluded, and merges the answers. A site that links to competitors A and C shows up in the A and C lookup, so its row says it links to 2 of 3 competitors and names them. The number of lookups is the number of combinations: 3 competitors and a minimum of 2 is 3 lookups, 5 and 2 is 10, 6 and 3 is 20. The limit is 20 lookups per run, and an input that needs more is rejected before anything is looked up. With many competitors, raise `minCompetitors`. Sites that link to every competitor need a single lookup. Then the Actor removes service domains, groups the linking hosts by root domain, looks up the domain rank and spam risk of the prospects in bulk, applies your filters and sorts the list: most competitors linked first, then by domain rank. Last, it looks up the strongest link of the top prospects (50 by default) to get the page URL, anchor text and target page, and sorts once more: within the same number of competitors, sites whose strongest link comes from using a competitor's product or from a legal page move down (see link types below). ### Service domains A link from a newsletter archive, a tracked click, an image on a CDN or a short link is a by-product of a product, not an editorial link someone chose to place, and nobody there can add a link to your site. These domains often link to many competitors at once, so without a filter they fill the top of the list. The Actor removes them with a built-in list of about 180 domains in five categories: | Category | What it covers | |---|---| | `email` | Email and newsletter sending, click tracking, hosted signup forms and campaign archives | | `cdn` | CDNs, file and image hosting | | `shortener` | URL shorteners and link-in-bio pages | | `redirect` | Ad, affiliate, click tracking and redirect domains | | `mirror` | Caches, archives, translation proxies and feed proxies | An entry also matches its subdomains. The list holds only domains whose whole purpose is the service, never the main site of a company, so a competitor's own blog or a large social network is not removed by it. Add your own entries in `serviceDomains`, for example a competitor's separate domain for its newsletter, help center, status page or app downloads, and switch the built-in list off with `useBuiltInServiceList: false`. The run summary counts the removed domains per category and lists them, so you can check what was removed. Hosting platforms where each subdomain belongs to a different owner (blog hosts, course and shop builders, help desk hosts) are not removed. The link index counts all sites on such a platform as one linking domain, so the row is marked with `hostedPlatform: true` and `whyListed` says to pitch the hosted sites, not the platform. Not filtered: domains that carry a competitor's name. A domain like that can be a service domain of the competitor, but just as often it is a partner agency, a review site or a template shop, which are real prospects. A name match alone is not reliable enough to drop a row. ### One row per site By default every row is one root domain (the registrable domain, such as `example.co.uk` for `blog.example.co.uk`). Linking hosts of the same site are merged into one row: the linked competitors are combined, backlinks and pages are added up, `linkingHosts` lists the hosts and `linkingSubdomains` gives the number of linking subdomains. Sites under a public hosting suffix, such as a `github.io` site, stay separate. The link index already reports most linking sites at the root domain level, so in practice the merge mostly catches `www.` and other host variants. Set `groupByRootDomain: false` for one row per host. Each lookup first reads a probe of 100 sites, strongest links first. Further pages are read only when at least 10% of that probe became prospects. It does this at most 5 times, and at most 10,000 sites per lookup. A lookup that finds no prospects stops after the probe. ### Input | Field | Default | Notes | |---|---|---| | `yourDomain` | example | Your site, for example `example.com`. `https://` and paths are removed. A leading `www` is removed when the host underneath still has a registrable name, so `www.example.com` becomes `example.com` and `www.gov.uk` stays. | | `competitors` | example | 1 to 20 competitor domains. Invalid entries, duplicates and your own site are dropped and listed in the run summary. | | `minCompetitors` | 2 | A prospect must link to at least this many competitors. With one competitor it is 1. | | `maxProspects` | 100 | Most prospects to return, up to 5,000. Each lookup reads this many sites at a time, at least 100 (200 after the first read) when a score filter is on. | | `includeDomainRank` | true | Add the domain rank and spam risk of each prospect. Needed for the two filters. | | `minDomainRank` | 0 | Drop prospects with a lower domain rank (0 to 100). | | `maxSpamRisk` | 40 | Drop prospects with a higher spam risk (0 to 100). 100 keeps all. Prospects without a value are kept. | | `dofollowOnly` | false | Count only dofollow links to the competitors. | | `groupByRootDomain` | true | One row per root domain. Off gives one row per linking host. | | `exampleLinksFor` | 50 | Look up the strongest link URL and link type for this many prospects from the top (0 to 200). 0 turns it off. | | `excludeDomains` | none | Up to 9 more sites you own. Sites that link to any of them are left out too. | | `skipProspects` | none | Up to 10,000 sites you already contacted. A root domain also skips its subdomains. Not charged. | | `useBuiltInServiceList` | true | Remove service domains with the built-in list. | | `serviceDomains` | none | Up to 1,000 more service domains to remove, with their subdomains. | | `includeSubdomains` | true | Count links to subdomains of your site and of the competitors. | | `useCache` | true | Reuse the result of the same analysis and the prospect scores from earlier runs. | | `cacheTtlDays` | 7 | Maximum age of cached results, 1 to 30 days. | | `pushSummaryToDataset` | false | Append the run summary to the dataset. | Example: ```json { "yourDomain": "crawlee.dev", "competitors": ["scrapy.org", "pptr.dev", "playwright.dev"], "minCompetitors": 2, "maxProspects": 200, "minDomainRank": 10, "serviceDomains": ["newsletter-domain-of-a-competitor.com"] } ``` Every entry is checked before anything is looked up. A domain must use letters, digits and hyphens only, have labels of up to 63 characters, and end in a known public suffix with a registrable name in front of it, so `co.uk`, `localhost` and `example.zzzz` are rejected. A competitor on the same site as your domain, more than 20 competitors, a `minCompetitors` higher than the number of competitors, more than 20 lookups, `exampleLinksFor` above 200, more than 1,000 `serviceDomains`, and a score filter you set with `includeDomainRank` off are all input errors. The default `maxSpamRisk` does not apply when `includeDomainRank` is off. An input error fails the run with a message that says what to change, and nothing is charged. ### Output One row per prospect site: ```json { "type": "prospect", "yourDomain": "crawlee.dev", "prospectDomain": "example-blog.com", "rootDomain": "example-blog.com", "competitorsLinked": 3, "competitorsTotal": 3, "linkedCompetitors": ["scrapy.org", "pptr.dev", "playwright.dev"], "domainRank": 41, "spamRisk": 12, "backlinksToCompetitors": 27, "referringPagesToCompetitors": 19, "linkingSubdomains": 2, "linkingHosts": ["example-blog.com", "docs.example-blog.com"], "onlyNofollow": false, "strongestLinkScore": 23, "strongestLink": { "competitor": "scrapy.org", "linkScore": 23, "referringPages": 9, "firstSeen": "2023-02-11T08:15:02.000Z", "url": "https://example-blog.com/posts/python-crawling-tools", "targetUrl": "https://scrapy.org/", "anchor": "Scrapy", "dofollow": true, "fromLegalPage": false, "lastSeen": "2026-10-03T11:20:41.000Z", "linkType": "mention" }, "hostedPlatform": false, "firstSeen": "2023-02-11T08:15:02.000Z", "whyListed": "Links to 3 of 3 competitors (scrapy.org, pptr.dev, playwright.dev) and not to crawlee.dev.", "competitorLinks": [ { "competitor": "scrapy.org", "backlinks": 14, "referringPages": 9, "nofollowPages": 0, "linkingSubdomains": 2, "linkScore": 23, "linkSpamRisk": 8, "firstSeen": "2023-02-11T08:15:02.000Z", "lostDate": null } ], "countsComplete": true, "source": "live", "fetchedAt": "2026-10-22T10:40:00.000Z" } ``` `competitorLinks` has one entry per linked competitor (one is shown above). `linkScore` is the strength of the links from the prospect to that competitor, on a 0 to 100 scale, and `linkSpamRisk` is the average spam risk of those links. `domainRank` and `spamRisk` describe the prospect site itself. `onlyNofollow` is true when every page that links to a competitor does so with nofollow links only. `firstSeen` is the earliest date the index saw a link from the prospect to one of the competitors. `prospectDomain` is the root domain of the site (or the host when `groupByRootDomain` is off). Sites on your own domain, a competitor's domain or one of your excluded domains are never listed. `strongestLink` is the prospect's strongest link to a competitor. Its `competitor`, `linkScore`, `referringPages` and `firstSeen` are always filled. The page fields (`url`, `targetUrl`, `anchor`, `dofollow`, `lastSeen`) are filled for the first `exampleLinksFor` rows when the index returns a live link, and are null otherwise. `fromLegalPage` is true when that page is a privacy, terms, cookie or other legal page. #### Link types Many sites link to a tool because they use it, not because they wrote about it: a university page links to a hosted signup form, a shop shows a "powered by" badge, a privacy policy names the newsletter service. Such a site is a customer of your competitor and rarely a realistic outreach target. `strongestLink.linkType` says which kind of link the example is: | Value | Meaning | |---|---| | `mention` | Any other link, usually from an article, a list, a review or an integration page | | `product use` | The link goes to a part of the competitor's product that its customers use (a hosted form, board, dashboard, sign-in or booking page on a subdomain such as `form.` or `app.`), or it is a "powered by" or referral badge | | `affiliate` | The link goes through an affiliate or referral path or parameter | | `legal page` | The link is on a privacy, terms or other legal page, or goes to one | | null | No example link was looked up for this row | Within the same number of linked competitors, `product use` and `legal page` rows are listed after the others. The type comes from the two URLs only. In the two live test runs it matched a manual check for 19 of 20 examples; the miss was a link to a shared board on a plain path, which counts as `mention`. Only the strongest link is checked, so a site with a strong product-use link and a weaker article link is still marked `product use`. #### When counts are lower bounds When a competitor pair has more common linking sites than the Actor read, the list is cut, and a site that links to three competitors can show up in only two of the cut lists. Its `competitorsLinked` is then a lower bound. Rows say so in `whyListed` and `countsComplete` is false, and the run summary lists the total and the number read for every lookup. A site that links to every competitor always has an exact count. Raise `maxProspects` to read more. ### Run summary Every run saves a `SUMMARY` record in the default key-value store: the competitors and lookups, the total, read count and number of reads of each lookup, the number of candidates, sites dropped because they belong to you or a competitor or are on your skip list, service domains removed per category (`droppedServiceDomains`, with the removed domains), hosts merged into root domains, sites removed by each score filter with a sample, example links found, taken from the cache and counted per link type, hosting platform rows, cache hits, charged events, rate-limit waits and the run status. ### Pricing Pay per event: - $0.05 once per run, charged when the first live lookup is performed, including a run that delivers no prospect. A run answered fully from the cache does not pay it. Invalid input is not charged. - $0.045 per lookup request, charged when that lookup is performed: one gap lookup, one domain rank or spam risk lookup, or one example link lookup. The first page of a gap lookup reads 100 sites. - $0.0002 per row actually read from a live lookup ($0.20 per 1,000). Rows that are not returned are not charged. - $0.002 per delivered prospect ($2 per 1,000), fresh or from the cache. On paid plans a prospect costs less, down to $0.0012 on Gold and higher. Cached results pay no lookup requests and no rows read. Invalid input and failed lookups are not charged, and removed service domains and sites on your skip list are never charged as prospects or as rows read. Examples: - 3 competitors, at least 2, 100 delivered prospects, example links for the top 50 from 3 competitors: $0.05 plus 3 gap lookups, 2 score lookups and 3 example link lookups at $0.045, 100 delivered sites and 50 example links read, and 100 prospects, $0.64 in total. Sites read and then removed are not in that total. - Without example links (`exampleLinksFor` set to 0) the same run is $0.495 in total. - The same analysis again within 7 days, from the cache: 100 prospects, $0.20 in total. - 3 competitors, all 3, 50 prospects without domain rank or example links: $0.05 plus $0.045, 50 delivered sites and 50 prospects, $0.205 in total. - 5 competitors, at least 2, 200 delivered prospects, example links for the top 50 from 4 competitors: $0.05 plus 10 gap lookups, 2 score lookups and 4 example link lookups, 200 delivered sites and 50 example links read, and 200 prospects, $1.22 in total. The spam risk filter is on by default. When it removes many sites, the Actor reads further and each extra page costs one more lookup request. Rows the filter removes are not charged, so a run with strict filters costs more only for the extra pages and for the prospects that remain. If you set a maximum charge per run, the Actor checks first that it covers the run fee, every planned gap lookup and one prospect. If it does not, the run fails before any lookup and nothing is charged. Otherwise it reads only as many sites as the limit pays for, delivers as many prospects as it can and lists the rest in the summary as skipped. Example links come last: when the limit is close, they are skipped so the prospects can still be delivered. ### Run time and limits A run with 3 competitors and 100 prospects takes a few seconds. Requests to the link index are rate limited per account. The Actor spaces its requests, waits and retries when a limit is hit, and records the waiting time in the summary. If a run is restarted or migrated, prospects that were already delivered are not charged again. ### Apify free plan limit Users on the Apify free plan get up to 20 prospects per run. Live data needs a paid Apify plan; a free-plan run returns cached results when they exist and does not call the live data source. The run then finishes normally with a status message about the limit, and the run summary names it under `freePlanLimit`. This limit was set by the developer of this Actor, not by Apify. The link data is paid per request, and runs by free plan users bring the developer no revenue. Any paid Apify plan removes the limit, and nothing else about the run changes. ### Notes - The link index is crawled continuously. A link added or removed today can take days or weeks to show up. - A site that links to you only from a page the index has not crawled yet can still be listed as a prospect. Check the top of the list by hand before you send outreach. - The domain rank is a link-based rank from the link index this Actor uses, from 0 to 100. It is not the metric of any SEO tool vendor, so it will not match scores you see elsewhere. - Use the domain each site actually serves. After a domain move, the old domain may still hold most of the links. - Sites that link to many competitors at once include press release networks and link directories with a high spam risk. The default `maxSpamRisk` of 40 removes most of them. Some sites have no spam risk value yet; they are kept. - A competitor's parent company or sister brands are not recognised as the competitor and can show up as prospects. Add them to `excludeDomains` (if they also link to you) or to `serviceDomains`. - The built-in service list covers widely used services. A small or regional service is not on it; add it to `serviceDomains`. - Tool directories and aggregator sites that list hundreds of products often link to every competitor. They pass the spam risk filter when their spam risk is low, and some of them are worth a submission. A `minDomainRank` of 20 to 30 removes the weakest of them. - The output has no contact details. It lists sites, not people. ### API ```bash curl -X POST "https://api.apify.com/v2/acts/datapulsehq~link-gap-finder/run-sync-get-dataset-items?token=YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{"yourDomain": "crawlee.dev", "competitors": ["scrapy.org", "pptr.dev", "playwright.dev"], "minCompetitors": 2}' ``` This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by any search engine or SEO software vendor, and its rank and spam risk values are not the metrics of any such vendor. All trademarks belong to their respective owners. # Actor input Schema ## `yourDomain` (type: `string`): The site you want links for, such as example.com. https://, www. and paths are removed. Sites that already link to it are left out of the results. ## `competitors` (type: `array`): 1 to 20 competitor domains. Invalid entries, duplicates and your own domain are dropped and listed in the run summary. ## `minCompetitors` (type: `integer`): Only list sites that link to at least this many of your competitors. Default 2, or 1 with a single competitor. The run needs one lookup per combination of this many competitors (3 competitors and 2 is 3 lookups), at most 20. ## `maxProspects` (type: `integer`): Most prospects to return, up to 5,000. Users on the Apify free plan get at most 20 per run. Each lookup reads this many rows at a time, at least 100 (200 after the first read) when a score filter is on. ## `includeDomainRank` (type: `boolean`): Look up the domain rank (0 to 100) and spam risk (0 to 100) of each prospect. Needed for the two filters below. ## `minDomainRank` (type: `integer`): Drop prospects with a lower domain rank. 0 keeps all. ## `maxSpamRisk` (type: `integer`): Drop prospects with a higher spam risk (0 to 100). Default 40, which removes most press release networks and link directories. 100 keeps all. Prospects without a spam risk value are kept. Needs "Add domain rank and spam risk". ## `dofollowOnly` (type: `boolean`): Count only dofollow links to the competitors, so sites that link with nofollow only are left out. ## `groupByRootDomain` (type: `boolean`): Group linking hosts by their root domain (blog.example.com and example.com become one row for example.com) with the competitors, pages and subdomains added up. Hosting platforms with a public suffix, such as github.io sites, stay separate sites. ## `exampleLinksFor` (type: `integer`): For this many prospects from the top of the list, look up the URL of their strongest link to a competitor, with anchor text, target page and link type. Sites whose strongest link comes from using a competitor's product (a hosted form, board or dashboard) or from a legal page are then listed after the others with the same competitor count. 0 turns it off. One lookup request per competitor and up to 50 prospects. ## `excludeDomains` (type: `array`): Up to 9 more domains you own. Sites that link to any of them are left out too. ## `skipProspects` (type: `array`): Up to 10,000 sites you already contacted or do not want. A root domain such as example.org also skips its subdomains. Skipped sites are not charged. ## `useBuiltInServiceList` (type: `boolean`): Remove domains that only carry links as a by-product of a service: email and newsletter infrastructure, CDNs and file hosting, URL shorteners and link-in-bio pages, ad, affiliate and redirect domains, and caches, archives and feed proxies. The run summary counts them per category. Removed domains are not charged as prospects. ## `serviceDomains` (type: `array`): Up to 1,000 more domains to remove, for example a competitor's separate domains for newsletters, help center, status page or app downloads. Each entry also removes its subdomains. Counted separately in the run summary. ## `includeSubdomains` (type: `boolean`): Count links to the subdomains of your domain and of the competitors. ## `useCache` (type: `boolean`): Reuse the result of the same analysis and the prospect scores from earlier runs. ## `cacheTtlDays` (type: `integer`): Maximum age of cached results. ## `pushSummaryToDataset` (type: `boolean`): Append the run summary as the last dataset row. It is always saved as SUMMARY in the key-value store. ## Actor input object example ```json { "yourDomain": "crawlee.dev", "competitors": [ "scrapy.org", "pptr.dev", "playwright.dev" ], "maxProspects": 100, "includeDomainRank": true, "minDomainRank": 0, "maxSpamRisk": 40, "dofollowOnly": false, "groupByRootDomain": true, "exampleLinksFor": 50, "useBuiltInServiceList": true, "includeSubdomains": true, "useCache": true, "cacheTtlDays": 7, "pushSummaryToDataset": false } ``` # Actor output Schema ## `results` (type: `string`): No description ## `summary` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "yourDomain": "crawlee.dev", "competitors": [ "scrapy.org", "pptr.dev", "playwright.dev" ] }; // Run the Actor and wait for it to finish const run = await client.actor("datapulsehq/link-gap-finder").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "yourDomain": "crawlee.dev", "competitors": [ "scrapy.org", "pptr.dev", "playwright.dev", ], } # Run the Actor and wait for it to finish run = client.actor("datapulsehq/link-gap-finder").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "yourDomain": "crawlee.dev", "competitors": [ "scrapy.org", "pptr.dev", "playwright.dev" ] }' | apify call datapulsehq/link-gap-finder --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,datapulsehq/link-gap-finder" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/5xwbMqAcVhpZPpNKk/builds/VZr2iG5UmHosaFwk9/openapi.json