# Site Diagnostics by Acinsoft (`acinsoft/acinsoft-site-diagnostics`) Actor

Diagnose a web page or crawl up to 10 pages. Check DNS, TLS, HTTP, technical SEO and broken links with configurable modules, structured evidence and pay-per-event pricing.

- **URL**: https://apify.com/acinsoft/acinsoft-site-diagnostics.md
- **Developed by:** [Acinsoft Services](https://apify.com/acinsoft) (community)
- **Categories:** Developer tools
- **Stats:** 3 total users, 2 monthly users, 11.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 useful page diagnoseds

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

### Website diagnostics for APIs and automations

Diagnose a public web page or a small website crawl through one configurable API.
Use structured evidence to review a website before delivery, investigate broken
links or feed recurring technical checks into your automation workflow.
Choose one page or a bounded crawl, select the checks you need, and pay for
useful pages and new link observations delivered in the report.

If input is omitted, the Actor checks `https://acinsoft.com/` with the bounded
`basic` page profile. Replace that default with the public URL you intend to
diagnose. The default keeps Console, API, scheduler and Store test runs executable.

### Choose your checks

- **basic**: DNS, TLS and HTTP observations.
- **seo**: all five modules, including SEO and link checks.
- **custom**: choose `dns`, `tls`, `http`, `seo` and `links` explicitly.

#### Review one page's SEO and links

```json
{
  "url": "https://example.com/",
  "profile": "custom",
  "modules": ["http", "seo", "links"],
  "mode": "page",
  "maximumLinks": 10
}
```

#### Review a small website crawl

```json
{
  "url": "https://example.com/",
  "profile": "seo",
  "mode": "crawl",
  "maximumPages": 5,
  "maximumDepth": 1,
  "maximumLinks": 10
}
```

Page mode checks one URL. Crawl mode visits up to 10 pages, depth 2, on the final
initial page's origin. Query-string links are excluded. DNS/TLS target the initial
hostname; TLS probes port 443. Robots rules apply to page/link requests and
redirects independently of SEO selection. Blocked pages are marked skipped;
unavailable policy stops access. The report explains partial coverage.

SEO inspects server HTML, title, description, headings, canonical and robots
signals. It interprets robots.txt, the conventional sitemap XML, HTML hreflang
and JSON-LD syntax/selected structure. It reports precise limits: child sitemap
indexes, reciprocal hreflang, schema vocabulary and rich-result eligibility
require further evaluation. Browser performance and accessibility are planned
extensions of this Actor. JavaScript rendering is outside this release.

### Results and consumption

The Dataset contains one row with the complete report, including per-page results
for crawls. OUTPUT adds integrity metadata, delivery status, observed event counts
and the Platform receipt. A finding indicates observed evidence, not guaranteed
health or indexability. A provider-recorded event is not a settled payment.

Pay-per-event pricing in USD:

| Event | Quantity | Price per event |
| --- | --- | --- |
| `site-page-diagnosed` | Useful page reports delivered | $0.003 |
| `site-link-checked` | New successful link observations; HTTP error statuses are evidence | $0.0001 |
| `apify-actor-start` | Starts recorded by Apify, including recovery starts | $0.00005 |

For configured page price P, link price L and start price S, the event amount is
`completed pages × P + new observed links × L + starts × S`.
A page without link checking contributes `P`; a five-page crawl with 30 new
link observations contributes `5P + 30L`, plus starts. Work limits are ceilings;
the report's completed units determine result-event quantities. One page without
links costs $0.00305 including one start. Ten useful pages and 200 new link
observations cost $0.05005 including one start.

Reused link responses add zero link units. Transport failures and skipped pages
add zero useful units. Technical quotas still count whole reports separately from
these commercial units. Selecting additional modules can add link work; basic and
SEO page observations share the configured page price in this initial contract.

`maximumChargeUsd` optionally tightens Apify's run budget. Both ceilings cover
result events and starts. Reaching the work budget preserves completed results.
The report's `resultChargeUsd` excludes starts. The private unpriced pilot accepts
work limits, with the monetary input reserved for pay-per-event runs.

### Delivery and recovery

The Actor validates original response bytes with SHA-256, saves an HMAC-signed
checkpoint, verifies the Dataset row, prepares a receipt, then records page/link
events with stable idempotency keys and confirms exact counts. Recovery preserves
the original run, input, account and price contract. An ambiguous API execution
or Dataset append requires reconciliation; an absent row alone does not authorize
another append. Each event batch retains its original quantity and key. Partial
observed counts remain pending rather than triggering an additional batch.

Keep CHECKPOINT and OUTPUT intact. ERROR records historical failures; successful
recovery can subsequently complete OUTPUT. Automatic restart should be disabled.
Cross-build recovery requires Platform's explicit compatibility process.

### Operator configuration

Use 128 MiB and limited permissions. The Node wrapper calls Platform; Platform
performs diagnostics. The timeout is 600 seconds for API work, delivery,
two bounded event-observation windows and receipts.

Required secret variables: `ACINSOFT_ACCOUNT_KEY` and
`ACINSOFT_APIFY_BROKER_API_KEY`. Set `ACINSOFT_API_ORIGIN` to the approved HTTPS
origin and `ACINSOFT_BILLING_MODE` to `private-pilot` or `pay-per-event`.
The paid contract additionally requires `ACINSOFT_PAGE_PRICE_USD`,
`ACINSOFT_LINK_PRICE_USD`, `ACINSOFT_START_PRICE_USD` and `ACINSOFT_PRICE_VERSION`.
These must match Platform's `Tools:SiteDiagnostics:Apify` configuration and Apify's
three flat-price events; page/link events are repeatable. Prices are explicit,
positive for page/link, nonnegative for start, up to eight decimal places.

The input contains job parameters; runtime credentials come from secret settings
and Apify's limited run token. Diagnostic results and checkpoint data live in the
run's Apify storage and the account-scoped Platform result store. URLs and observed
site metadata form part of the report; use public targets appropriate to that
storage scope. Secrets are excluded from reports and logs.

Free-plan consumers receive up to 10 useful reports per verified Apify consumer
for this Tool over their lifetime, sharing a pool of 50 reports per rolling
seven days. A paid Apify plan uses separate counters. Shared trial exhaustion
preserves the individual's remaining allowance. Event prices and Apify credits
still apply; the trial allowance is an execution quota, not a billing discount.
Initial admission allows one concurrent execution shared by the integration
account and up to 10 requests per minute per consumer. Each report can contain
several billable pages and links. Recovery may add a start event while preserving
the original report quantities.

# Actor input Schema

## `url` (type: `string`):

Public HTTP(S) URL with a hostname, default port and no credentials or fragment. Defaults to Acinsoft's public site for unattended and Store test runs.

## `profile` (type: `string`):

Basic: DNS, TLS and HTTP. SEO: all five modules. Custom: select modules below.

## `modules` (type: `array`):

Provide only with custom: dns, tls, http, seo, links. Use each module once. The Actor and API validate these values.

## `mode` (type: `string`):

Crawl requires HTTP, SEO or links and follows same-origin links without query strings.

## `maximumPages` (type: `integer`):

Maximum attempted pages in crawl mode, including the initial page. Page mode uses one.

## `maximumDepth` (type: `integer`):

Maximum link depth from the initial page. Zero examines only the initial page.

## `maximumLinks` (type: `integer`):

Maximum links to check on each page when the links module is selected.

## `resolver` (type: `string`):

Public recursive resolver used for DNS observations and public target checks.

## `maximumChargeUsd` (type: `number`):

Optional tighter ceiling for result events plus Actor starts, up to eight decimal places. Apify's run ceiling also applies. Available in pay-per-event mode.

## `requestId` (type: `string`):

Optional UUID. Use a new value for a new report. Recovery uses the original run, signed checkpoint and input.

## Actor input object example

```json
{
  "url": "https://acinsoft.com/",
  "profile": "basic",
  "mode": "page",
  "maximumPages": 5,
  "maximumDepth": 1,
  "maximumLinks": 10,
  "resolver": "cloudflare"
}
```

# Actor output Schema

## `result` (type: `string`):

No description

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

// Prepare Actor input
const input = {
    "url": "https://acinsoft.com/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("acinsoft/acinsoft-site-diagnostics").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 = { "url": "https://acinsoft.com/" }

# Run the Actor and wait for it to finish
run = client.actor("acinsoft/acinsoft-site-diagnostics").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 '{
  "url": "https://acinsoft.com/"
}' |
apify call acinsoft/acinsoft-site-diagnostics --silent --output-dataset

```

## MCP server setup

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

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/DnftDQ4vdGcHhZb9j/builds/89O8QYCk8AgEmtjud/openapi.json