# Search Visibility Analyzer — SISTRIX Alternative (`khadinakbar/sistrix-alternative`) Actor

Measure Google search visibility for a domain and keywords you supply. Export observed ranks, transparent sample-based visibility scores, source URLs, and optional comparison-domain results.

- **URL**: https://apify.com/khadinakbar/sistrix-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** SEO tools, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 keyword visibility observations

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

## Search Visibility Analyzer — SISTRIX Alternative

Measure Google search visibility for a domain and keywords you supply. Export observed ranks, transparent sample-based visibility scores, source URLs, and optional comparison-domain results. For SEO analysts, the dataset combines observed keyword ranks with a visibility summary calculated for the supplied keyword sample.

### Workflow: put the results to work

Use a keyword list that reflects the market you want to measure. Compare the target domain and optional comparison domains under the same search settings. The aggregate score describes this supplied sample and is distinct from the proprietary SISTRIX Visibility Index.

### What you get

- One validated dataset observation for each successfully processed keyword.
- The target domain's current organic rank within the requested Google depth, or a valid zero-score observation when it is not found.
- A transparent `visibilityPoints` score: `100 / observed organic rank`; the run-level `visibilityScore` is the average across your supplied keyword sample.
- A source results URL, timestamp, country, language, device, provider run ID, and optional ranks for up to three comparison domains.
- Stable `OUTPUT`, `RUN_SUMMARY`, and `STATE` records for automation and polling.

The score is deliberately transparent and comparable only when you use the same keyword list, locale, device, and depth. It does **not** recreate or estimate the proprietary SISTRIX Visibility Index.

### How this workflow compares with SISTRIX

| Capability | This Actor | SISTRIX suite |
| --- | --- | --- |
| Input | Your domain and up to 20 supplied keywords | A proprietary SEO data platform and broader product suite |
| Visibility measure | Explicit average of `100 / current observed rank` | Proprietary Visibility Index methodology and keyword corpus |
| Time coverage | One current run | Historic product data and trend tooling |
| Output | Source-linked JSON rows and compact key-value summaries | Hosted dashboards, reports, and product workflows |
| Billing and cost model | Bounded Pay per event report plus Apify platform usage | Subscription suite |
| Effective efficiency | A completed call yields an exportable dataset and compact run summary | Broader suite workflows are selected for ongoing workspace needs |
| Integration and automation | Apify API, schedules, and Actor chaining can consume the records | Suite integrations and automation depend on the selected SISTRIX plan |

### Workflow: from keyword list to visibility decision

An agency starts with a target domain, a focused keyword sample, locale, device, depth, and optional competitors. The Actor then requests the same current Google result pages for every supplied keyword, persists one evidence row per successful observation, and calculates the transparent aggregate. Next, the team reads `OUTPUT.visibilitySnapshot` for the decision, opens the Dataset for source URLs and ranks, and can export the result or schedule a like-for-like repeat with the same input.

### Input

```json
{
  "targetDomain": "apify.com",
  "keywords": [
    "apify",
    "web scraping platform",
    "data extraction tools"
  ],
  "countryCode": "us",
  "languageCode": "en",
  "device": "desktop",
  "depth": 20,
  "compareDomains": ["semrush.com", "ahrefs.com"]
}
```

`targetDomain` accepts a domain or URL and is normalized to a hostname. `keywords` accepts 1–20 phrases; blank and duplicate items are removed. `depth` is 10, 20, 50, or 100. `compareDomains` is optional and accepts up to three domains.

No third-party API key or subscription is required. The Actor invokes Apify's Google Search Results Scraper and passes through underlying Apify platform usage.

### Output and outcomes

The Dataset contains `keyword_visibility_observation` records. Each record includes `targetRank`, `visibilityPoints`, `sampleVisibilitySharePercent`, `comparisonDomains`, `checkUrl`, `observedAt`, and `providerRunId`.

The `OUTPUT` key contains the aggregate snapshot:

```json
{
  "outcome": "COMPLETE",
  "visibilitySnapshot": {
    "targetDomain": "apify.com",
    "keywordCount": 3,
    "keywordsRanked": 2,
    "visibilityScore": 52.78,
    "averageRank": 3.5
  }
}
```

Terminal outcomes are:

- `COMPLETE` — every selected keyword produced a valid observation and at least one ranked result was found.
- `VALID_EMPTY` — valid observations were persisted, but the target was not found at the requested depth.
- `PARTIAL` — some requested observations could not be persisted; inspect `RUN_SUMMARY`.
- `INVALID_INPUT` — the request was accepted but did not meet semantic validation; correct the provided values.
- `UPSTREAM_FAILED` or `CONFIG_ERROR` — no usable report could be completed; retry later and inspect `RUN_SUMMARY`.

### Programmatic use

Start a run with the Actor API using the input above, then read the default Dataset and the `OUTPUT` key.

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~sistrix-alternative/runs?waitForFinish=300" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  --data '{
    "targetDomain": "apify.com",
    "keywords": ["apify", "web scraping platform"],
    "countryCode": "us",
    "languageCode": "en",
    "device": "desktop",
    "depth": 20
  }'
```

For an agent or MCP workflow:

> Create a US desktop visibility snapshot for `apify.com` using the supplied keywords. After completion, read `OUTPUT` for the terminal outcome and aggregate, then read the Dataset for per-keyword rank evidence, source URLs, timestamps, provenance, and any partial-run warning.

### Builder's note

I built this around one source-linked observation per supplied keyword because a caller can inspect exactly what changed between two comparable runs. The transparent `100 / rank` rule keeps the result useful for a focused workflow while leaving proprietary suite metrics and broader SEO research in their proper context.

### Responsible use and best results

This Actor requests public Google result pages through Apify's maintained provider. Submit only public, non-sensitive search terms and domains, use the data lawfully, respect applicable search-engine terms and rate limits, and operate only on sources you are authorized to access. Search results change frequently, so use the same inputs when comparing reports and treat every score as evidence for its recorded run only.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/sistrix-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `keyword-visibility-observation` | Keyword visibility observation | Charged only after one complete source-linked keyword visibility observation is persisted. Underlying Google-search and Apify platform usage are additional. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Independent alternative

This Actor provides the specific workflow described above. It is not affiliated with or endorsed by SISTRIX; the named product and its trademarks belong to their respective owners.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

# Actor input Schema

## `targetDomain` (type: `string`):

Domain to find in Google organic results, for example apify.com. A full URL is accepted and normalized to its hostname, and subdomains count as matches. This does not check a Google Business Profile.

## `keywords` (type: `array`):

Google searches to measure, one phrase per item. Blank and duplicate entries are removed, with at most 20 selected keywords. The Actor does not discover a keyword universe for you.

## `countryCode` (type: `string`):

Two-letter Google country code such as us, gb, or de. It defaults to us and is recorded on every observation. This is not a city-level location selector.

## `languageCode` (type: `string`):

Google interface language code such as en, de, or fr. It defaults to en and is recorded on every observation. It does not translate the supplied keyword.

## `device` (type: `string`):

Google result device profile. Choose desktop or mobile because observed rankings can differ between them. This is not an operating-system selector.

## `depth` (type: `integer`):

Organic positions to inspect for each keyword. Higher depths request more result pages and increase underlying platform usage. This is not an unlimited rank crawl.

## `compareDomains` (type: `array`):

Up to three domains to compare against the same observed Google results. Duplicate entries and the target domain are removed. This reports the same transparent caller-keyword score, not a market-share estimate.

## Actor input object example

```json
{
  "targetDomain": "apify.com",
  "keywords": [
    "apify",
    "web scraping platform",
    "data extraction tools"
  ],
  "countryCode": "us",
  "languageCode": "en",
  "device": "desktop",
  "depth": 20,
  "compareDomains": [
    "semrush.com",
    "ahrefs.com"
  ]
}
```

# Actor output Schema

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

One validated visibility observation per successfully processed keyword.

## `output` (type: `string`):

Terminal outcome, aggregate visibility snapshot, charges, and warnings.

## `runSummary` (type: `string`):

Provider, input, persistence, and billing diagnostics.

## `state` (type: `string`):

Small terminal lifecycle record for polling clients.

# 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 = {
    "targetDomain": "apify.com",
    "keywords": [
        "apify",
        "web scraping platform",
        "data extraction tools"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/sistrix-alternative").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 = {
    "targetDomain": "apify.com",
    "keywords": [
        "apify",
        "web scraping platform",
        "data extraction tools",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/sistrix-alternative").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 '{
  "targetDomain": "apify.com",
  "keywords": [
    "apify",
    "web scraping platform",
    "data extraction tools"
  ]
}' |
apify call khadinakbar/sistrix-alternative --silent --output-dataset

```

## MCP server setup

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

```

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/9JTDNUmxkhWehfHqs/builds/oq6Q8W9W5r4vIFEkc/openapi.json