# Comment System Detector (`ib4ngz/comment-system-detector`) Actor

Detects comment providers and states across supplied URLs and bounded internal links.

- **URL**: https://apify.com/ib4ngz/comment-system-detector.md
- **Developed by:** [Iqbal R](https://apify.com/ib4ngz) (community)
- **Categories:** Automation, Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

### What does Comment System Detector do?

**Comment System Detector finds comment systems on websites and reports whether visitors can currently comment.** Submit one or more public URLs, including homepages, and the Actor can follow eligible internal links to look for article or post pages within your configured crawl limits.

Each unique supplied site produces one final structured record containing the detected provider, commenting state, form availability, confidence score, and supporting evidence. Supported providers include WordPress native comments, Disqus, Facebook Comments, Hyvor Talk, Commento, native HTML comment forms, and custom comment widgets.

Use the Actor from Apify Console or through the Apify API. Results can be scheduled, monitored, downloaded, or connected to other Apify integrations.

### Why use Comment System Detector?

- **Publisher discovery:** find websites with active reader discussions.
- **Technology research:** identify which comment provider a site uses.
- **Website audits:** locate open, closed, unavailable, or login-required comment areas.
- **Migration planning:** inventory comment systems before moving content platforms.
- **Lead enrichment:** add community and engagement signals to website datasets.
- **Ongoing monitoring:** schedule repeated checks to notice changes in commenting availability.

The Actor returns evidence with every positive detection, making results easier to review and filter by confidence.

### How to use Comment System Detector

1. Open the Actor in Apify Console.
2. Add one or more pages under **Start URLs**.
3. Set **Maximum crawl depth** to `0` for only the supplied pages, or use `1` or more to follow internal links.
4. Set a total page limit with **Maximum pages per run**.
5. Click **Start**.
6. Open the **Output** tab to review or download one final result per unique site.

The Actor is read-only. It may scroll to reveal lazy-loaded comment widgets, but it does not post comments, submit forms, or sign in to accounts.

Supplied URLs sharing the same hostname are grouped into one site target. If a comment system is detected on any page, the Actor immediately finalizes that site, skips navigation for its remaining queued URLs, and continues other sites independently. Intermediate page analyses are not written to the Dataset.

### Input

The following input analyzes Apify's homepage and follows one internal-link level:

```json
{
    "startUrls": [
        { "url": "https://apify.com" }
    ],
    "maxCrawlDepth": 1,
    "maxRequestsPerCrawl": 150,
    "maxLinksPerPage": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
}
```

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | `https://apify.com/` | One or more public HTTP or HTTPS URLs, without a fixed application-level maximum. |
| `maxCrawlDepth` | integer | `1` | Internal-link levels followed from each start URL. `0` analyzes only supplied URLs. |
| `maxRequestsPerCrawl` | integer | `150` | Maximum total pages analyzed across all start URLs; the default automatically expands to cover every unique start URL and must be at least `1`. |
| `maxLinksPerPage` | integer | `50` | Maximum eligible internal links queued from each page; must be at least `1`. |
| `proxyConfiguration` | object | disabled | Optional Apify Proxy or custom rotating proxy configuration. |

Internal crawling stays on the start website, respects `robots.txt`, removes common tracking parameters, skips common account and administration paths, and avoids non-HTML files. Article-like links are prioritized when the crawl budget is limited.

Link discovery for each site ends as soon as a comment system is detected, even when a higher maximum depth was configured.

#### Using Apify Proxy

Enable Apify Proxy from the input editor, then optionally choose proxy groups and a country available to your Apify account:

```json
{
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
}
```

Apify Proxy availability, groups, geographic options, and usage charges depend on your Apify plan. If you provide a subdivision, also select its country.

#### Using custom proxies

To rotate your own proxies, keep Apify Proxy disabled and provide one or more complete proxy URLs:

```json
{
    "useApifyProxy": false,
    "proxyUrls": [
        "http://username:password@proxy.example:8000",
        "socks5://proxy.example:1080"
    ]
}
```

Do not enable Apify Proxy and custom proxy URLs at the same time. Proxy configuration and credentials are not included in Dataset output.

### Output

The Actor creates exactly one Dataset item per unique hostname, treating `www.apify.com` and `apify.com` as the same site. The first supplied URL for that hostname becomes `startUrl`. A `detected` result is written as soon as the comment system is found. An `unknown` or `failed` result is written as soon as that site's own request queue is exhausted; only a global crawl limit can defer it until the run ends.

```json
{
    "status": "unknown",
    "startUrl": "https://apify.com/",
    "url": "https://apify.com/",
    "depth": 0,
    "commentSystem": {
        "detected": false,
        "provider": {
            "id": "unknown",
            "name": null,
            "type": "unknown"
        },
        "state": "unknown",
        "form": {
            "available": false,
            "loginRequired": false
        },
        "confidence": 0
    },
    "evidence": [],
    "meta": {
        "rendered": true,
        "pagesAnalyzed": 1,
        "failedRequests": 0,
        "completionReason": "crawl_finished_without_detection"
    }
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. Results are also available through the Apify API.

### Data table

| Field | Description |
| --- | --- |
| `status` | Final outcome: `detected`, `unknown`, or `failed`. |
| `startUrl` | First supplied URL representing the unique site. |
| `url` | Final analyzed URL after redirects. |
| `depth` | Link distance from the start URL; start pages use `0`. |
| `commentSystem.detected` | Whether a credible comment system was found. |
| `commentSystem.provider` | Provider ID, display name, and provider type. |
| `commentSystem.state` | `open`, `login_required`, `closed`, `unavailable`, or `unknown`. |
| `commentSystem.form` | Whether commenting is available and whether login is required. |
| `commentSystem.confidence` | Detection confidence from `0` to `1`. |
| `evidence` | Signals supporting the selected provider and state. |
| `meta.rendered` | Whether at least one page was successfully browser-rendered. |
| `meta.pagesAnalyzed` | Number of successfully analyzed pages for this site. |
| `meta.failedRequests` | Number of requests that exhausted all retries. |
| `meta.completionReason` | Why the final result was emitted. |

### How much does it cost to detect website comment systems?

Cost mainly depends on the number of pages rendered, page load time, and selected Actor memory. A run with depth `0` and a few start URLs is usually cheaper than a homepage crawl that follows dozens of internal links. Use `maxRequestsPerCrawl` as the primary cost control. Proxy traffic may add separate charges depending on the selected Apify Proxy group or your external proxy provider.

You can test small runs using the usage included with the current Apify free plan. For recurring or larger crawls, review the average cost of representative runs before scheduling at scale.

### Tips and advanced options

- Start with depth `1` when submitting a homepage; this often reaches article pages without exploring too broadly.
- Increase depth gradually and keep a firm `maxRequestsPerCrawl` limit.
- Add article or category URLs directly when you already know where content is located.
- Use confidence and evidence when deciding which detections require manual review.
- A result with state `unknown` can still identify a provider when its interactive controls are blocked or delayed.
- Submit multiple start URLs in one run when auditing several independent websites.
- Use proxies only when needed; they can improve access reliability but may increase cost and latency.

### FAQ, disclaimers, and support

#### Does the Actor crawl external websites linked from a page?

No. Only eligible internal links associated with each start website are considered.

#### Is every supplied URL analyzed?

URLs on the same hostname are grouped. They remain seed candidates until one page detects a comment system; any remaining queued URLs for that site are then skipped. URLs can also be skipped when blocked by `robots.txt` or when a configured global limit is reached.

#### What happens after a comment system is found?

The Actor immediately writes the positive result, stops following deeper links, and skips navigation for remaining queued URLs on that site. Other sites continue independently.

#### Are pages without a detection included in the Dataset?

No intermediate page records are stored. The Dataset contains one final item per unique site: the detected page, or an `unknown`/`failed` result emitted when that site's work finishes.

#### Does the Actor submit comments or log in?

No. It only observes rendered pages and never submits comment or authentication forms.

#### Do I need a proxy?

Not always. Start without a proxy for publicly accessible pages. Enable Apify Proxy or custom proxies when websites block direct data-center traffic, require a specific location, or need IP rotation.

#### Why was a page not analyzed?

The page may exceed the configured depth or request limits, be blocked by `robots.txt`, require authentication, fail to load, or point to a skipped non-HTML resource.

#### Can every custom comment system be identified?

No detector can recognize every private or heavily customized implementation. Unknown or low-confidence results may require manual review.

Automated website access may be governed by website terms, privacy requirements, `robots.txt`, and applicable law. Only analyze websites you are authorized to access. Use the Actor's **Issues** tab for bug reports, provider requests, or support. Custom configurations and tailored data extraction solutions are available on request.

# Actor input Schema

## `startUrls` (type: `array`):

One or more public HTTP or HTTPS pages to analyze. Defaults to https://apify.com when omitted.

## `maxCrawlDepth` (type: `integer`):

How many internal-link levels to follow from each start URL. Use 0 to analyze only the supplied URLs. Discovery stops early after a comment system is found.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum total number of pages analyzed across all start URLs.

## `maxLinksPerPage` (type: `integer`):

Maximum number of eligible internal links added from each analyzed page.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy or custom proxy settings used for page requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "maxCrawlDepth": 1,
  "maxRequestsPerCrawl": 1,
  "maxLinksPerPage": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        {
            "url": "https://apify.com"
        }
    ],
    "maxCrawlDepth": 0,
    "maxRequestsPerCrawl": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("ib4ngz/comment-system-detector").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 = {
    "startUrls": [{ "url": "https://apify.com" }],
    "maxCrawlDepth": 0,
    "maxRequestsPerCrawl": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("ib4ngz/comment-system-detector").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 '{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "maxCrawlDepth": 0,
  "maxRequestsPerCrawl": 1
}' |
apify call ib4ngz/comment-system-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ib4ngz/comment-system-detector"
        }
    }
}

```

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/RXI5oADcWE5sbVIWj/builds/gpklkqufhgpKEUAFv/openapi.json