# Apify Store Rank Tracker & Visibility Monitor (`monkey.d.scraping/store-visibility-monitor`) Actor

Track Actor positions in anonymous Apify Store search results. Compare keyword visibility with a saved baseline and export JSON/CSV reports. Monitor up to 20 Actors across 20 queries; errors stay distinct from absence.

- **URL**: https://apify.com/monkey.d.scraping/store-visibility-monitor.md
- **Developed by:** [Monkey D. Scraping](https://apify.com/monkey.d.scraping) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 observed search queries

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

## Apify Store Rank Tracker & Visibility Monitor

See whether your Actors appear in the first 100 results of an **anonymous Apify Store API search**, and compare the observed positions with an earlier run. Track up to 20 Actors across 20 queries and export one clear observation per Actor and query to JSON or CSV.

Use it to review visibility for the search phrases your product serves. It measures the API sample, not traffic, demand, sales or a global Store rank. It does not run the Actors you follow.

### Who this is for

- **Actor developers:** take a baseline for the phrases your Actor serves, then compare a later observation after a listing change. Movement alone does not prove that the edit caused it.
- **Teams with a portfolio:** observe several Actors in the same query with one search request and one query event, rather than running each tracked Actor.
- **Automation maintainers:** export structured observations and distinguish an API outage from an Actor leaving the observed sample.

Start with three relevant queries and one Actor. Use the same configuration for the next comparison. For interpretation, prefer observations separated by more than the possible five-minute cache window and look for repeated patterns across several runs. This tool does not estimate search volume or recommend keywords based on demand.

### Get your first result

1. Paste an Actor's Store link, `publisher/actor` name or Actor ID into **Actors to follow**.
2. Enter one or more search queries. Keep the prefilled example for a small first test.
3. Run and open **Visibility report and next steps**. Use **Observed positions** for the exportable dataset, and check **Completeness and limitations** before interpreting absence or movement.

```json
{
  "actorIds": ["monkey.d.scraping/telegram-keyword-search-channel-scraper"],
  "queries": ["telegram keyword search"]
}
```

You get an observation even when the Actor is absent from the sample. Actor names are resolved anonymously; use an ID if name resolution is unavailable. Different entries resolving to the same Actor are rejected rather than billed twice.

### Compare with an earlier run

Run once without a baseline. For the next run, select that run's key-value store in **Previous snapshot store** and keep the same Actors, query order, sample limit and filters.

Only a completed delivery from version 0.2 or later can be used as a baseline. The `COMPLETION` record indicates eligibility. Older prototype snapshots must be replaced by a new first run. An incompatible baseline is rejected before any Store search starts. The earlier store is read, never overwritten.

`positionsGained` is positive when the observed numerical position improves, negative when it falls, and empty when positions cannot be compared. Two checks within five minutes may share cached results. Do not treat an immediate repeat as evidence of sustained improvement.

### Read the observations correctly

| State | Meaning |
| --- | --- |
| `present` | The Actor appeared at this original API response position. |
| `not_observed` | The Actor was not in this bounded sample. It may appear outside the sample; this is not proof of deindexing. |
| `unknown` | The search failed or was skipped. This is never recorded as absence or rank loss. |

Comparison states distinguish comparable positions, entering or leaving the sample, absence in both samples and unknown evidence. A result can be valid and empty. A failed API request cannot establish an empty result.

The dataset includes the query, Actor label and ID, state, position, timestamp, sample size, filters, search surface, comparison and any safe failure reason. `SUMMARY` reports observed, failed and skipped query counts. `complete=false` means you must review the incomplete queries before interpreting the run.

### Filters and limits

- Up to 20 distinct Actors and 20 distinct queries; up to 200 characters per input entry.
- One Store request per query; maximum 100 results and no search pagination.
- Category IDs use AND semantics. Publisher, pricing model and agentic eligibility filters are optional. They restrict the sample and must remain identical for comparisons.
- Categories are normalized to lowercase, trimmed and deduplicated. Unknown category IDs are reported as errors. Use official IDs rather than guessing.
- Pricing and agentic eligibility filters can lag changes on the source platform. Eligibility filtering is not personalization.
- API reads have bounded timeouts. New searches stop after the execution budget or the service spending limit is reached; remaining observations are `unknown`.

Anonymous API results can differ from authenticated API/MCP results and the Store website. The Actor never uses your token for Store searches or public Actor-name resolution. There is no remote `sortBy` option. Changes in search infrastructure or the Store catalog can affect comparisons independently of your listing edits.

### Pricing and spending limits

**$0.001 per Actor start + $0.005 per successfully observed query** ($5 per 1,000 query events). Platform usage is included. Up to 20 tracked Actors are included in each query; there is no per-row fee.

A successful query is charged even when no tracked Actor appears in the sample. Failed and skipped queries have no query fee; the start fee still applies. One successful query costs $0.006 in total; nine cost $0.046; twenty cost $0.101. The minimum selectable run budget is $0.006.

Rows are saved before a query event is charged. Before starting the next query, the Actor checks whether another event fits the run budget. If the budget only covers part of the input, remaining queries are reported as unknown. The Pricing tab is authoritative for active rates.

### Files, automations and delivery

- **REPORT.html:** readable observations, limitations, query billing and the store ID for your next baseline.
- **Dataset:** one observation per requested query and Actor; use JSON or CSV export.
- **SNAPSHOT:** reusable configuration and observed sample.
- **COMPARISON:** present when a compatible baseline was supplied.
- **SUMMARY:** completeness, skipped work, safe errors and query billing counts.
- **RESULTS.csv:** convenient CSV with formula prefixes neutralized. JSON retains the original text.
- **COMPLETION:** written last, after the promised outputs were saved. `usableAsBaseline=true` is required for a later comparison.

A failed or aborted run may leave partial dataset rows. Rows already delivered can have been charged. Do not use an interrupted run as a baseline. Ambiguous dataset writes are not retried, and resurrecting a run that has already begun delivery is rejected to prevent duplicate writes or charges. Start a fresh run if you choose to repeat the work; that is a separate run and budget.

You can connect the dataset to your own workflow or schedule runs yourself. This Actor creates no schedules, sends no notifications and does not automatically select or replace a baseline. A completed snapshot with some unknown queries can be compared; those queries remain unknown.

### Troubleshooting

- **Invalid input or baseline:** correct the input or take a new baseline with this release. No search is performed for an incompatible baseline.
- **HTTP 400:** check category IDs and filters. **429:** the Store limited requests; use a later manual retry. Rejected requests stop further queries in this run.
- **Timeout or transport error:** evidence is unavailable. Review the partial run before retrying; do not classify the tracked Actor as absent.
- **Every query failed:** the run fails after saving diagnostics when storage is available. No successful-query fee applies.
- **An Actor name cannot be resolved:** check its Store URL or use its ID. The monitor does not require private access to the tracked Actor.

Snapshots are observations, not signed proofs. Editing a stored snapshot can invalidate its meaning even if its structure remains readable.

### Frequently asked questions

#### Does this track Apify Store keyword rankings?

It tracks the observed position of selected Actors for your search queries in the anonymous Store API response, up to the first 100 results. It does not claim a global rank or reproduce every visitor's personalized Store page.

#### Can I compare my Actors with competitors?

Yes. Supply their public Actor names, links or IDs alongside yours, up to 20 distinct Actors. The monitor reads search results; it never starts the tracked Actors or purchases their services.

#### Does this improve Store SEO automatically?

No. Use snapshots to observe visibility before and after listing edits. The Actor does not edit listings, estimate keyword demand or guarantee ranking improvements.

#### Can I export keyword positions to an automation?

Yes. Use the dataset's JSON or CSV output. Preserve the query, timestamp, sample size and observation state so downstream workflows do not turn failed checks into ranking losses.

### Store API transition

The client is designed for the one-page contract announced for November 15, 2026. The post-transition live check is separate from tests against fixtures. No current result certifies future backend behavior.

[Official Store API announcement](https://apify.com/change-log/apify-store-api)

# Actor input Schema

## `actorIds` (type: `array`):

One Actor per line: paste an Apify Store URL, publisher/actor name, or 17-character ID. Up to 20 Actors; none are executed.

## `queries` (type: `array`):

One query per line, up to 20. Each query produces an anonymous API sample.

## `baselineStoreId` (type: `string`):

Choose the key-value store of a completed run from version 0.2 or later. Keep identical Actors, query order, limits and filters. Leave empty for your first run.

## `limit` (type: `integer`):

One page only. No additional search pages exist under the announced contract.

## `categories` (type: `array`):

Optional official category IDs. Invalid categories produce an error; do not guess IDs.

## `username` (type: `string`):

Restricts the search sample; use the same filter in baseline and current run.

## `pricingModel` (type: `string`):

Official pricingModel value, for example PAY_PER_EVENT. Filters can lag recent price changes.

## `allowsAgenticUsers` (type: `boolean`):

Unset means no filter. This is eligibility filtering, not personalized search; freshness may lag edits.

## Actor input object example

```json
{
  "actorIds": [
    "monkey.d.scraping/telegram-keyword-search-channel-scraper"
  ],
  "queries": [
    "telegram keyword search"
  ],
  "limit": 100,
  "categories": []
}
```

# Actor output Schema

## `report` (type: `string`):

No description

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

No description

## `csv` (type: `string`):

No description

## `snapshot` (type: `string`):

No description

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

No description

## `completion` (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 = {
    "actorIds": [
        "monkey.d.scraping/telegram-keyword-search-channel-scraper"
    ],
    "queries": [
        "telegram keyword search"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("monkey.d.scraping/store-visibility-monitor").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 = {
    "actorIds": ["monkey.d.scraping/telegram-keyword-search-channel-scraper"],
    "queries": ["telegram keyword search"],
}

# Run the Actor and wait for it to finish
run = client.actor("monkey.d.scraping/store-visibility-monitor").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 '{
  "actorIds": [
    "monkey.d.scraping/telegram-keyword-search-channel-scraper"
  ],
  "queries": [
    "telegram keyword search"
  ]
}' |
apify call monkey.d.scraping/store-visibility-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,monkey.d.scraping/store-visibility-monitor"
        }
    }
}
```

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/Gca5mkdAKseFeXYBP/builds/0FlfuDVhk7LZzM50i/openapi.json