# Domain Diagnostics by Acinsoft (`acinsoft/acinsoft-domain-inspector`) Actor

Diagnose public domains with DNS records and TTLs, HTTPS checks, TLS certificate validity, RDAP registration and email configuration signals. Choose Cloudflare or Google and export structured results with source timings and explicit coverage limitations.

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

## Pricing

from $0.002 / domain inspection

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

## Domain Inspector by Acinsoft

Inspect a public domain's DNS, HTTPS, TLS certificate, RDAP registration and email configuration in one structured report. Choose Cloudflare or Google for DNS resolution. Get records, TTLs, source timings and explicit warnings when evidence is incomplete. No browser, PDF generation or proxy is required.

### Version 1.0

This commercial release provides English documentation, input forms and result labels. Input keys and report formats remain compatible with the validated 0.1 release. Apify identifies the source version as `1.0` and automatically assigns build numbers starting at `1.0.1`.

### Quick start

Enter an exact public DNS name:

```json
{"domain":"example.com","resolver":"cloudflare"}
```

You can also choose `google`. Run the Actor, then open **JSON report** or **Exportable results**. Each run inspects one domain. You do not need to supply an Acinsoft API key.

| Input | Description |
| --- | --- |
| `domain` | Required public DNS name, without a URL scheme, port or credentials. IP addresses and batches are not supported. |
| `resolver` | `cloudflare` (default) or `google`. Arbitrary DNS servers and automatic resolver substitution are not supported. |
| `requestId` | Optional UUID identifying an operation. Keep it when retrying in a new run. Duplicates return 409 without another Acinsoft inspection unit. If omitted, the Actor uses its run ID. |

### What you receive

- DNS records and TTLs using the selected resolver over TCP/53.
- HTTPS status and TLS certificate observations.
- RDAP registration data when available from the registry.
- SPF, DMARC and other email-related observations, including MTA-STS when advertised in DNS.
- A summary, findings with source and severity, per-source status and timing, and overall inspection duration.
- A JSON report and one Dataset row, exportable through Apify as JSON, CSV or Excel.

The output includes `requestId`, `actorRunId`, `executionUid` and a verified SHA-256 hash of the original Acinsoft report bytes. The hash does not describe the output wrapper or a CSV export.

### Understanding the results

Report formats v3/v4 include `summary`: certificate and registration days remaining, HTTP status, and SPF/DMARC observations for the exact name queried. Days are calculated in UTC at inspection start and rounded down. `null` means insufficient evidence, never a guarantee of safety.

Each source retains its own status, data and duration. A partial report can still be useful and billable. For example, a domain may have DNS and HTTPS data while RDAP is unavailable. If no MTA-STS DNS advertisement is found, the policy status is `not_applicable` and no policy HTTP request is made. Failed DNS lookup is `unavailable`, not proof that a record is absent.

Report v4 can observe expired certificates, hostname mismatches and untrusted chains. `tls.status=ok` means an observation was obtained, not that the certificate is valid: inspect `chainAndHostnameValid` and `validationErrors`. The summary includes `certificate_untrusted` when appropriate. The measurement handshake sends no application data. HTTPS, RDAP and MTA-STS requests still reject invalid certificates.

There are no live certificate-revocation checks or AIA intermediate downloads; an incomplete chain may appear untrusted. Missing DMARC on a subdomain does not evaluate its parent domain's policy. Email records do not prove deliverability or correct configuration. RDAP/IANA infrastructure resolves independently of the selected report DNS resolver.

This is a point-in-time technical observation, not a security certification, reputation assessment, global propagation test or full security audit. No SLA or mass-throughput guarantee is offered. Historical report formats v2/v3/v4 remain supported; saved checkpoints are not reinterpreted.

### Pricing

- **USD 0.002 per useful report delivered** — USD 2 per 1,000 reports, billed individually rather than in prepaid blocks.
- **USD 0.00005 per Actor start** — an additional USD 0.05 for 1,000 starts.

Thus, 1,000 successful single-start runs cost USD 2.05 in Actor events. A restart or resurrection may add a start fee without producing another inspection. Review the run budget before resuming. A valid partial report counts as a useful report; an empty response or a mere error does not incur the report event. A rejected run can still incur its start fee.

The Actor uses pay-per-event pricing. An event receipt is not an invoice or proof of a settled payment. Free-plan usage does not establish a paid payout to Acinsoft.

### Capacity and rate limits

Initial shared capacity is **one active inspection**, up to **30 requests per minute** across the connection and **10 requests per minute per consumer**. The shared monthly operating ceiling is **1 million report units**, not an individual reservation or a throughput guarantee; other tools in the integration account also share its aggregate ceiling.

There is no waiting queue. Requests can receive 429 when capacity is busy or a limit is reached. Space out runs. A rejected inspection does not incur the report event, but starting the Actor can still incur USD 0.00005. There are no automatic retries.

### Privacy and permissions

The Actor runs with limited permissions, 128 MiB of memory, a 180-second default timeout and no automatic restart. This integration does not configure proxies or schedules.

The domain and execution-verification data are sent to the Acinsoft backend. Apify injects a run token, which is forwarded only to verify the run; it is not written to OUTPUT or logs. The connection checks the exact Actor and authorized build. Operator credentials are secret environment variables, not input fields, and are not applied during the build. No administrative Apify token is configured in the Actor.

Acinsoft stores request attribution and metrics in its dedicated integration account. The technical artifact has a 24-hour validity period; that does not imply automatic deletion of request history or receipts. Apify retains INPUT, OUTPUT, Dataset, CHECKPOINT and run data according to its storage settings. Never enter secrets in `domain` or share credentials with support.

### Recovery and billing receipts

CHECKPOINT preserves the original report and progress, signed and bound to the run, input and account. It contains no credentials. On restart, an existing report is reused rather than inspected again. An uncertain Dataset write is not repeated automatically. Do not delete or edit CHECKPOINT to repair a run.

The Actor prepares an Acinsoft receipt after verifying delivery to Dataset and before attempting the report charge. It then confirms the event by querying Apify. OUTPUT includes `receipt` on confirmation. Failed confirmation preserves pending evidence; recovering the same run reuses the receipt and does not create another inspection unit. OUTPUT is not replaced by a billing error.

ERROR records the last failed attempt. Its timestamp does not invalidate a subsequently recovered OUTPUT. `receipt_http_*` requires checking confirmation, not starting another inspection. Receipts retain delivery and event metadata independently of the 24-hour technical artifact. Past charges without a prepared receipt are not reconstructed.

For `execution_outcome_unknown`, `dataset_outcome_unknown` or an uncertain charge, review the original operation before retrying. Recovery is conservative to avoid duplicates; automatic recovery from every interruption is not guaranteed. Keep the original build when recovering a prepared receipt. Switching builds requires an explicit operator recovery authorization.

### Troubleshooting and support

| Error | Meaning / next step |
| --- | --- |
| 401 / 403 | Ask the operator to check the credential, account and execution profile. Do not submit credentials in the input. |
| 409 | A duplicate operation or conflicting state was detected. Inspect the original run before retrying. |
| 429 | Shared capacity or a rate/usage limit was reached. Space out runs; check the applicable limit. |
| 503 | Inspect the original execution before repeating the request. |

For support, share only `requestId`, `actorRunId`, `executionUid` and the error code through the Actor's Issues tab. Never share tokens or API keys.

# Actor input Schema

## `domain` (type: `string`):

Public DNS name without a URL, port or credentials.

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

Uses the selected profile without automatic substitution. Queries use TCP/53.

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

UUID identifying an operation. Keep it when retrying. A duplicate returns 409 without a new Acinsoft unit. If omitted, this run ID is used.

## Actor input object example

```json
{
  "domain": "acinsoft.com",
  "resolver": "cloudflare"
}
```

# Actor output Schema

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

DNS, HTTPS, TLS, RDAP and email observations with resolver, TTL and timings. Includes execution, hash, delivery and Acinsoft event receipt (not payment settlement). Some sources may be incomplete.

## `dataset` (type: `string`):

One row per inspection with summary and full evidence. Export from Dataset.

# 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 = {
    "domain": "acinsoft.com"
};

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

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

```

## MCP server setup

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

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/yCWiafdlYYiAEHVjL/builds/jgxUVlkWydV3ZtG50/openapi.json