# Agent Link Checker (`nefissiez/agent-link-checker`) Actor

Check public URLs before using them in automated workflows. Distinguish missing pages, blocked access, rate limits, server errors and redirects. Returns structured evidence without browser or LLM calls. Pay only for completed URL checks.

- **URL**: https://apify.com/nefissiez/agent-link-checker.md
- **Developed by:** [uras aydinlioglu](https://apify.com/nefissiez) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 url checkeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Agent Link Checker

Check HTTP status and redirect evidence before a URL enters an automated workflow.

Send up to 100 public URLs. Receive one structured result per unique URL, including the final address, HTTP status, redirect chain, check time and an explicit outcome category. Useful for checking links in generated reports, reviewing source lists and validating URLs before a larger crawl.

### What it checks

- Responding HTTP endpoints and redirects.
- Missing pages: HTTP 404 and 410.
- Authentication, denied access and rate limits as separate outcomes.
- Temporary server failures, DNS/TLS/network failures and redirect loops.
- Duplicate URLs, including fragment-only variants, once per run.

A responding endpoint is **not proof of the content or truth of a citation**. This tool does not inspect page text, validate quotations, identify soft 404s, evaluate reputation or judge source accuracy.

### Input

```json
{
  "urls": ["https://example.com/", "https://www.iana.org/domains/reserved"],
  "timeoutSeconds": 8,
  "maxRedirects": 5
}
```

The maximum is 100 input URLs. Each URL has a total time limit of 2–15 seconds, including DNS, requests and redirects. The maximum redirect count is 0–5. Processing is sequential with a short interval between URLs.

### Output

```json
{
  "inputUrl": "https://example.com/",
  "finalUrl": "https://example.com/",
  "statusCode": 200,
  "category": "reachable",
  "method": "HEAD",
  "redirects": [],
  "checkedAt": "2026-09-09T10:54:07.385Z",
  "durationMs": 215,
  "billable": true,
  "message": "HTTP endpoint responds. This does not verify the page content or any claim."
}
```

This example came from a local, unbilled check. A run summary is stored under SUMMARY in the default key-value store. Output is a snapshot from the time of the run. Re-run when fresh evidence is required.

| Category | Interpretation |
| --- | --- |
| reachable | Direct HTTP 2xx response |
| redirected | Redirect chain ends at HTTP 2xx |
| missing | HTTP 404 or 410 |
| authentication\_required | HTTP 401 |
| access\_blocked | HTTP 403 or 451; existence unknown |
| rate\_limited | HTTP 429; no retry |
| server\_error | HTTP 5xx; may be temporary |
| http\_error | Other non-success HTTP response |
| redirect\_loop, redirect\_limit, redirect\_invalid | Redirect chain was not resolved |
| invalid\_input, blocked\_target | URL cannot be checked under this tool's limits |
| timeout, network\_error | Result remains uncertain |

### Current pricing

The live Actor fee is **$2 per 1,000 completed URL checks**. Platform usage is included for users and is not billed as a separate line item. This is a small usage-priced utility; revenue and payout timing are not guaranteed.

An HTTP response classified as reachable, redirected, missing, authentication required, access blocked, rate limited, server error or HTTP error counts as one completed check. These responses all provide useful evidence and are billable. Input errors, security rejections, unresolved redirects and network failures have no Actor event fee; platform compute costs may still apply. Duplicates do not create additional result rows.

Only the custom url-checked event is charged. Dataset-item and startup charges are disabled. The implementation stops when the platform reports the run's event charge limit.

Automatic resumption is not supported. If Apify restarts or migrates an execution, it stops before replaying checks to avoid duplicate charges within the same run. Results already delivered remain in the dataset; a fresh run performs and charges for its checks again. Disable automatic restart on error for this Actor.

### Scope and privacy

Public IPv4 destinations on standard HTTP or HTTPS ports only. Private networks, credentials in URLs, IPv6-only hosts and custom ports are unsupported. Every redirect destination is revalidated. The checked IP is pinned for each request.

No browser, proxies, login cookies, LLM calls or page-body storage. HEAD is tried first; HTTP 405/501 triggers a GET whose body is discarded. Sites can respond differently to a real browser. Bot protection is reported, not bypassed.

Provide only URLs you are authorized to check. Query strings are retained in output, so do not submit private signed URLs, passwords or tokens. The input and results are stored in the requesting account's Apify run storage under its retention settings. Automatic deletion is not implemented.

### Local use

Node.js 22 or newer is required. The standalone checker and tests have no external dependencies.

```text
node --test test/checker.test.mjs
node src/cli.mjs examples/INPUT.json examples/LIVE_CHECK.json
```

For the Apify entry point, install dependencies and run with the Apify SDK's local storage or on the platform. See LAUNCH.md for publication steps.

# Actor input Schema

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

1–100 public HTTP(S) URLs. No credentials, private networks, or nonstandard ports. Identical URLs and fragment-only differences are checked once.

## `timeoutSeconds` (type: `integer`):

Includes DNS, requests and redirect chain. Allowed range: 2–15.

## `maxRedirects` (type: `integer`):

Follow up to this many redirects. A longer chain is reported as unresolved and has no Actor event fee.

## Actor input object example

```json
{
  "urls": [
    "https://example.com/"
  ],
  "timeoutSeconds": 8,
  "maxRedirects": 5
}
```

# Actor output Schema

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

One result per unique URL submitted to the run.

## `summary` (type: `string`):

Input, output, billable counts and the stop reason for this run.

# 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://example.com/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nefissiez/agent-link-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://example.com/"] }

# Run the Actor and wait for it to finish
run = client.actor("nefissiez/agent-link-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://example.com/"
  ]
}' |
apify call nefissiez/agent-link-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nefissiez/agent-link-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/0N5JwWF5OUid7yvmI/builds/4A5di4B0MyQ2sj760/openapi.json