# Backlink Checker & Link Change Monitor | Aura (`automatron/backlink-checker`) Actor

Check known backlink placements for missing links, anchor text, nofollow/sponsored attributes, redirects and noindex. Compare saved evidence across runs. CSV/JSON and MCP. $0.004 per completed page; unknown results are not billed.

- **URL**: https://apify.com/automatron/backlink-checker.md
- **Developed by:** [Automatron](https://apify.com/automatron) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 verified pages

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Backlink Checker & Link Change Monitor | Aura

**Aura Verification · Know whether the link you paid for is still there.**

Check whether a delivered backlink is still present. Supply placement URLs and the expected destination; receive timestamped evidence of the link, anchor text, `nofollow`/`sponsored` attributes, redirects, canonical URL and noindex signals. Export JSON or CSV for a client report, or let an AI agent call the same checker.

**$0.004 per completed page check. Unknown results are not billed.** This verifies URLs you already have; it does not discover a domain's backlinks or report search rankings.

### Try one page

Start with the [placement audit example](https://apify.com/automatron/backlink-checker/examples/aura-backlink-placement-audit), or use the [change-check example](https://apify.com/automatron/backlink-checker/examples/aura-backlink-change-check) to compare saved evidence. Apify copies the example into your account, where you can replace the sample inputs and control the run budget.

Open **Input**, keep the prefilled example and select **Start**. It checks a public IANA reference page for its RFC 6761 link. Then replace the example with your own placement URLs and destination.

```json
{
  "urls": ["https://www.iana.org/domains/reserved"],
  "targetUrl": "https://www.iana.org/go/rfc6761"
}
```

The example was checked locally on 23 October 2026: the link was present. Pages can change. A completed check returns `status: "checked"`, `linkPresent`, matching links and an observation time. Export the dataset as CSV or JSON using Apify's dataset controls.

### Use it for

- **Placement handoff:** verify supplied links before sending a campaign report.
- **Link retention:** repeat a saved check to notice removed links or changed link attributes.
- **Partner and affiliate pages:** check an exact destination and capture its current anchor text.
- **Agent workflows:** add verification before an agent marks a placement as checked.

Start with 25 URLs. Each run accepts one expected destination, so group placements by destination. Matching is exact after URL normalization and removal of the link fragment: a different path or trailing slash can be a different link. Leave `targetUrl` blank to collect up to 20 links per page without testing a particular destination.

### From placements to a client report

1. Group your delivered placement URLs by expected destination.
2. Check a small batch and export the results. Review missing links, changed anchors, sponsored attributes and noindex signals before handoff.
3. Keep the evidence digests with your report. Repeat the check later with those digests to compare selected evidence.

A removed link and an unreadable page are different outcomes. A completed source check can report a missing link; a blocked or unsupported page is `unknown` and needs another verification method. Both appear in the output so you can account for every supplied URL.

### Understand the result

| Field | Meaning |
| --- | --- |
| `status` | `checked` for a completed HTTP-source observation; `unknown` when it cannot establish a result |
| `linkPresent` | Whether the exact destination appears; `null` without a target or for an unsupported rendered page |
| `links` | Matching destinations, anchor text and `rel` attributes, up to 20 |
| `noindex` | A noindex signal in HTML robots/googlebot metadata; not proof of Google indexing |
| `canonical` / `finalUrl` | The declared canonical URL and the URL reached after redirects |
| `observedAt` | UTC time of the observation |
| `digest` / `changed` | Selected evidence fingerprint and comparison with a previous run |

`linkPresent: false` describes the returned HTML. Login, blocked responses or JavaScript-only links can require browser verification. Unknown results include a `reason` and are not charged.

### Repeat checks and changes

Save the returned `digest` for each `sourceUrl`. On the next run, supply `baseline` as an object mapping those source URLs to their previous digests. Keep the same `targetUrl`. `changed: false` means the selected evidence is unchanged; `changed: true` means it differs; `changed: null` means no baseline was supplied.

The digest compares link, canonical, noindex and final URL evidence, not all page content. Save a one-off check as **Aura · Placement audit**, or a repeat check as **Aura · Link retention**, followed by your own project label. Schedule repeats within your own account limits. A schedule does not refresh the baseline automatically; update it from the previous dataset when comparing consecutive runs. No automatic email alerts are included.

### Connect an AI agent

Use this [Apify MCP configuration](https://mcp.apify.com?tools=automatron/backlink-checker):

```json
{
  "mcpServers": {
    "aura-backlink-checker": {
      "url": "https://mcp.apify.com?tools=automatron/backlink-checker"
    }
  }
}
```

Authorize with your own Apify account, follow the returned tool schema, and retrieve the run's dataset. Actor ID: `NY5K2KCzocidqkkaq`. [Apify's MCP guide](https://docs.apify.com/mcp) covers compatible clients. Agents can also use [Apify prepaid access through x402/MPP](https://docs.apify.com/agents/payments); Apify manages those payments.

### Price and limits

| Completed page checks | Actor charge |
| --- | --- |
| 25 | $0.10 |
| 100 | $0.40 |
| 1,000 across one or more runs | $4.00 |

Only `verified-page` is charged. Unknown pages are not billed. Usage pass-through and Standby are disabled, and the Actor uses limited permissions. Your Apify account plan and limits still apply.

Inputs are limited to 1,000 public HTTPS URLs and 60 KB. Each page is limited to 128 KB, three redirects and ten seconds per request. Requests are sequential, with a five-minute check budget and time reserved to save results before the six-minute run timeout. Remaining URLs return `unknown` with `run_deadline_reached`, `free_preview_limit`, or `charge_limit_reached`; retry only unknown pages in smaller batches. The 1,000-URL input limit does not promise 1,000 completed checks per run. Non-monetized local demonstrations stop after ten pages.

This checker does not bypass access controls, use paid proxies, buy links or guarantee rankings. If charging or output is interrupted, the run stops for reconciliation to prevent duplicate charging.

### Frequently asked questions

**Does it find every backlink to a domain?** No. Supply the placements you already have, such as a delivery sheet from a link-building campaign. Aura checks those pages against one exact destination per run.

**Will this certify a backlink or guarantee its SEO value?** No. “Aura Verification” means timestamped HTTP-source evidence. It is not a certification, domain-authority score, Google indexing check or ranking guarantee.

**Can I use it without a subscription?** The Actor charges per completed page. Your own Apify account and its limits still apply. Unknown results are unbilled, including blocked pages and unfinished inputs.

**Does it run continuously?** Save a task and schedule it in your own Apify account. Each scheduled run uses that account's allowance and maximum charge. Update the baseline between runs when you want a comparison with the previous observation. Alerts and automatic baseline rotation are not included.

**Can an AI agent use the same service?** Yes. Use the MCP configuration above or Apify's documented prepaid agent access. Keep payment limits in the caller's account and inspect unknown results before making a claim about a placement.

### Support and feedback

Aura is maintained by Matthias Mandiau. For support, open an Actor issue with the run ID and a redacted example; keep private client URLs out of public issues.

After using the checker, share an honest review from its Apify Store page. What worked, what did not, and what would make it more useful? All feedback helps improve the checker.

# Actor input Schema

## `urls` (type: `array`):

Public HTTPS pages to check. Try the one-page example, then replace it with your placement URLs. Start with 25 pages; up to 1,000 inputs are accepted, but slow batches may need multiple runs.

## `targetUrl` (type: `string`):

Exact destination to find, including the path and trailing slash. Leave blank to collect up to 20 links per page without checking a specific destination.

## `baseline` (type: `object`):

Map each source URL to its digest from the previous dataset. Keep the same destination URL. Changed compares link, canonical, noindex and final URL evidence, not the full page text.

## Actor input object example

```json
{
  "urls": [
    "https://www.iana.org/domains/reserved"
  ],
  "targetUrl": "https://www.iana.org/go/rfc6761"
}
```

# Actor output Schema

## `results` (type: `string`):

One record per processed URL. Unknown pages are not billed.

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://www.iana.org/domains/reserved"
    ],
    "targetUrl": "https://www.iana.org/go/rfc6761"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automatron/backlink-checker").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": ["https://www.iana.org/domains/reserved"],
    "targetUrl": "https://www.iana.org/go/rfc6761",
}

# Run the Actor and wait for it to finish
run = client.actor("automatron/backlink-checker").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 '{
  "urls": [
    "https://www.iana.org/domains/reserved"
  ],
  "targetUrl": "https://www.iana.org/go/rfc6761"
}' |
apify call automatron/backlink-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automatron/backlink-checker"
        }
    }
}
```

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 <APIFY_API_TOKEN>` 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/NY5K2KCzocidqkkaq/builds/BD6SBSVolpIILklzT/openapi.json