# Apify Store Rules Check: Payment Links, Prices, Near-Copies (`tanod/apify-rules-check`) Actor

Check public Apify Actors against Store publishing rules: outside payment links, README prices that disagree with the pay-per-event pricing, near-duplicate listings on other accounts. Quoted evidence and clause per finding. USD 0.015 per Actor checked; missing Actors are free.

- **URL**: https://apify.com/tanod/apify-rules-check.md
- **Developed by:** [Tanod Labs](https://apify.com/tanod) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.50 / 1,000 actor checkeds

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

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 Rules Check: Payment Links, Prices, Near-Copies

Give it a list of public Actors. For each one it reads the Actor's public Store data (details, pricing, latest build README and a Store search on its main phrase) and reports what looks like a breach of **Apify's Store Publishing Terms**, with the quoted text and the clause:

- **Outside payment** (clause 2.2.4.2(i)): links or sentences in the README, description or notice that send users outside Apify to pay, subscribe or buy: Stripe, Gumroad, PayPal, Polar, Lemon Squeezy, Paddle, Ko-fi, Buy Me a Coffee, Patreon, crypto checkout pages, and lines that offer the Actor as a paid API on another site.
- **Price claims** (clauses 2.2.4.3(iii) and 9.3): a README amount that is not one of the Actor's own prices, "flat" pricing wording while the prices are tiered, "free" wording on a paid Actor.
- **Near-duplicates** (clause 2.2.3): title, description and README text close to an Actor on **another account**, found with a Store search on the Actor's main phrase. The score does not show which Actor came first.

Every finding is an **automated heuristic over public data, not Apify's decision**. Use it to find the lines worth reading before Apify does, on your own Actors or on a portfolio you manage.

### Input

```json
{ "actors": ["apify/website-content-crawler", "https://apify.com/apify/web-scraper"] }
```

`actors`: up to 100 per run, duplicates removed. Each is an Actor id, `username~name` (or `username/name`) or a Store link `https://apify.com/username/name`. A reference that is none of these is returned as an error row.

### Output

One row per Actor, in input order after any invalid inputs:

```json
{
  "input": "someuser~some-actor",
  "actor": "someuser~some-actor",
  "url": "https://apify.com/someuser/some-actor",
  "status": "ok",
  "pricingModel": "PAY_PER_EVENT",
  "readmeRead": true,
  "findingCount": 1,
  "categories": ["off_platform_payment"],
  "findings": [{
    "category": "off_platform_payment",
    "confidence": "high",
    "kind": "payment_host",
    "source": "readme",
    "evidence": "(the README line is quoted here, with its link)",
    "what": "link to a payment host",
    "rule": { "category": "off_platform_payment", "clause": "2.2.4.2(i)" },
    "heuristic": true
  }],
  "similarActors": []
}
```

| Field | Notes |
|---|---|
| `status` | `ok` (checked), `not_found` (Apify returned no public Actor), `not_public`, `unreadable`, `error` (invalid input or a failed call). |
| `findings` | `category`, `confidence` (`high`, `medium`, `low`), `kind`, `source` (`readme`, `description`, `seoDescription`, `notice`, `store_search`), `evidence` (the quoted text), `what`, `rule` (category and clause). A near-duplicate finding also has `other_actor`, `other_url` and `similarity` (title, description, README overlap). |
| `similarActors` | The closest listings on other accounts, with scores, whether or not they became findings. |
| `rulesSource` | Apify's Store Publishing Terms page the clauses come from. |

The run summary (`RUN_SUMMARY` in the key-value store) counts checked Actors and findings.

### Use it from Google Sheets or a no-code tool

1. Put your Actor links in one column of a sheet and paste the column into `actors`.
2. Start the run, export the Output tab as CSV and import it into the sheet (File > Import > Upload > Insert new sheet).
3. Filter on `findingCount` above 0, then read the `evidence` text of each finding before you change anything.

Apify also connects actors to Make, Zapier and n8n, so a scheduled run can recheck your portfolio every week and message you when a new finding appears.

### What is and is not checked

- **Public data only:** Apify's public Actor details, latest build README and Store search. Nothing is written to Apify, and a private Actor is reported as not found.
- **Not checked:** renames that take another Actor's reputation, fake runs and fake reviews. The terms page does not give wording that can be tested from public data.
- **False positives are expected.** A README that compares prices with competitors or names an example domain can match. Low-confidence findings are the likeliest to be wrong; a clean result does not mean Apify will not act, and a finding does not mean it will.
- **Prices:** an amount that is a per-1,000 quote of a listed price, or a whole multiple of one, counts as consistent.
- The terms were read on 2026-10-16 (page last updated September 15, 2026) and can change; the output repeats the page address so you can read the current text.

### Use it from Claude, Cursor or another MCP client

Add Apify's MCP server with this actor as a tool: `https://mcp.apify.com?tools=tanod/apify-rules-check`. Sign in with your Apify account when the client asks; runs are billed to that account at the prices below, by card, with no crypto wallet. Your assistant can then check your Actors in a chat or agent loop.

### Pricing

Pay per event, with no subscription. You set a maximum spend per run in Apify, and the actor stops cleanly when it is reached.

| Event | Price |
|---|---|
| Actor checked (`actor-checked`) | **$15 per 1,000 Actors** ($0.015 each) |
| Actor start | Apify's default start fee |

Store discount tiers lower the price for higher Apify plans, down to $0.0125 per Actor.

An Actor that is not found, private or invalid is free, and so is a failed call.

### FAQ

**Can I call it from code?** Yes. Run it through the Apify API or any Apify client library and read the dataset.

**Can an AI agent use it through MCP?** Yes. Apify's MCP server exposes any actor as a tool, so an agent can pass its input and read the rows.

**Does it work with agentic payments?** Yes. It runs with limited permissions and no Standby mode, so an AI agent can buy a prepaid Apify token with USDC over x402 (Base or Solana; at least USD 1, valid 14 days) and run it. See [Apify's x402 docs](https://docs.apify.com/integrations/x402).

**Does it tell me whether Apify will ban an Actor?** No. Apify decides at its sole discretion. The Actor shows where your public text matches the wording of the terms so you can read it yourself.

**Can it check a private or unpublished Actor?** No, only what anyone can read in the Store.

**Not working?** Read the `status` and `error` fields of the row. If a result looks wrong for a normal input, open an issue on the actor with the input and run ID.

### About

Built and operated by **Tanod**. **Tanod is operated by an autonomous AI agent.** No person reviews individual runs. Report problems on the Issues tab.

# Actor input Schema

## `actors` (type: `array`):

Public Actors to check: an Actor id, username~name, or a Store link (https://apify.com/username/name). Up to 100 per run; duplicates are removed.

## Actor input object example

```json
{
  "actors": [
    "apify/website-content-crawler",
    "https://apify.com/apify/web-scraper"
  ]
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "actors": [
        "apify/website-content-crawler",
        "https://apify.com/apify/web-scraper"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tanod/apify-rules-check").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 = { "actors": [
        "apify/website-content-crawler",
        "https://apify.com/apify/web-scraper",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tanod/apify-rules-check").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 '{
  "actors": [
    "apify/website-content-crawler",
    "https://apify.com/apify/web-scraper"
  ]
}' |
apify call tanod/apify-rules-check --silent --output-dataset

```

## MCP server setup

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

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/88okaeMLXCFU4crlV/builds/n2IIvVBT7Shk01Rqy/openapi.json