# Actor Trust Check: Score Any Apify Actor Before You Call It (`tudorlane/actor-trust-check`) Actor

Is this Apify Actor reliable and safe to call? Get a 0-100 trust, quality and reliability score, badge and plain reasons from public stats: success rate, users, freshness, docs, pricing.

- **URL**: https://apify.com/tudorlane/actor-trust-check.md
- **Developed by:** [Tudor Lane](https://apify.com/tudorlane) (community)
- **Categories:** Developer tools, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 actor checks

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

## Actor Trust Check: Score Any Apify Actor Before You Call It

Before your AI agent (or you) spends money on an Apify Actor, check whether it's likely to work. Pass an Actor name; get a 0-100 trust score, a badge and plain-English reasons, all from public data you can verify yourself.

**Use when:**

- choosing between several Actors for the same job (e.g. "best Actor for Google Maps", "compare Instagram scrapers")

- checking whether an Actor is reliable or safe to use before running it

- verifying an Actor's success rate, freshness and pricing before spending money on it

- Works on any public Apify Actor: `username/actor-name`, `username~actor-name`, an Actor ID or an apify.com URL

- Score 0-100 and a badge: **trusted** (85+), **ok** (70-84), **caution** (55-69), **avoid** (under 55)

- Plain reasons ("96.2% of 270,242 runs succeeded in the last 30 days", "Default build is 23 days old")

- Every raw signal returned, so an agent can apply its own rules

- Confidence (low/medium/high) so a new Actor with a handful of runs isn't confused with a proven one

- Optional probe run (off by default, cost-capped at $0.01) that actually starts the Actor once

- No text from the scored Actor's README or description is copied into the output, so nothing in it can steer your agent

### Quick start

Click **Start** with the default input, or send:

```json
{"requests": ["apify/web-scraper", "compass/crawler-google-places"]}
```

Send many Actors in one run (up to 100). Settings outside `requests` (`probe`, `max_probe_usd`) apply to every item.

### Sample output

Real run, 20 Nov 2026 (default build 0.1.1):

| Actor | Score | Badge | Confidence | 30-day success | Users (30 days) | Build age | Pricing |
|---|---|---|---|---|---|---|---|
| apify/instagram-scraper | 100 | trusted | high | 99.7% | 71,219 | 0 days | pay per event |
| clockworks/tiktok-scraper | 100 | trusted | high | 98.4% | 38,027 | 3 days | pay per event |
| apify/website-content-crawler | 99 | trusted | high | 97.1% | 12,064 | 3 days | free |
| compass/crawler-google-places | 99 | trusted | high | 97.2% | 49,147 | 4 days | pay per event |
| apify/web-scraper | 97 | trusted | high | 96.2% | 1,364 | 23 days | free |
| tudorlane/sanctions-watchlist | 80 | ok | low | 100.0% | 1 | 22 days | pay per event |
| tudorlane/uk-property-sold-prices | 65 | caution | low | n/a | 1 | 0 days | pay per event |

Example `reasons` for apify/web-scraper:

```json
[
 "96.2% of 270,242 finished runs succeeded in the last 30 days (7,522 failed, 2,805 timed out; aborted runs not counted).",
 "Default build is 23 days old.",
 "1,364 users in the last 30 days, 127,333 all time, 182,063,998 runs all time; live 2,815 days.",
 "Rated 4.7/5 from 100 reviews.",
 "Docs: has input schema, output schema and a full README.",
 "Pricing: free (you pay Apify platform usage)."
]
```

The two tudorlane Actors are ours and are new, so they show low confidence; one has no public 30-day run stats yet.

### How the score works

Rules version `2026-11-20.v1`. The same rules apply to every Actor, including our own (tudorlane Actors are marked with a disclosure line). We don't change the rules after seeing results.

| Part | Points | What we measure (public Apify API and Store data) |
|---|---|---|
| Reliability | 40 | 30-day success rate = succeeded / (succeeded + failed + timed out). Aborted runs are left out (usually stopped by the user). Small samples are pulled towards a neutral 85% (worth 10 runs). 98%+ scores 40, 70% or lower scores 0. |
| Freshness | 20 | Age of the default build: up to 30 days 20, 90 days 16, 180 days 12, 365 days 6, older 0. A failed default build scores 0. |
| Adoption and track record | 20 | Users in the last 30 days (up to 8), total runs (up to 4), days live (up to 3), Store reviews (up to 5; fewer than 3 reviews counts as neutral 2). |
| Documentation | 10 | Input schema 3, README of 1,500+ characters 4 (300+ gets 2), output/dataset schema 2, description 1. |
| Pricing clarity | 10 | Free, pay-per-event or pay-per-result with named events 10; monthly rental 6; pricing not visible 3. |

Caps: an Apify notice (such as under maintenance) caps the score at 40; deprecated caps it at 20; no default build caps it at 30. A probe that fails with no results takes 10 points off.

Confidence is **low** under 50 finished runs or 5 users in 30 days, **medium** under 1,000 runs, otherwise **high**.

### Probe run (optional)

Set `"probe": true` to also start one short test run of each Actor, **in your own Apify account**, using the Actor's own example input with a 60-second timeout. It only runs when the cost can be capped under `max_probe_usd` (default $0.01, max $0.05):

- Pay-per-event (the developer pays the compute, so memory doesn't affect your cost): Apify's hard spend limit (`maxTotalChargeUsd`) is set to your cap. Skipped if the Actor demands a higher minimum.
- Pay-per-result: limited to 1 result, and only if one result costs less than the cap.
- Free: run at the Actor's own default memory, estimated at memory x 60 s of platform usage; skipped if over the cap or the default memory is above 1 GB (probing with less memory than the developer intended would be unfair).
- Monthly rental or unknown pricing: always skipped.
  The output says whether it ran, why it was skipped, the status, result count, run time and usage.

### Use cases

- An AI agent checks a tool before calling it and picks the most reliable of several similar Actors
- Developers vet a third-party Actor before building it into a pipeline
- Schedule a weekly check of the Actors you depend on and catch drops in success rate early
- Actor builders see how their own listing looks on objective signals

### Pricing

Pay per event: **$0.002 per Actor check**. Rows with errors (e.g. Actor not found or not public) are not charged. No subscription. Probe runs, if you turn them on, are billed by Apify to your account at the scored Actor's own prices (capped as above).

### Output

One dataset row per Actor: `actor`, `actor_id`, `title`, `url`, `score`, `badge`, `confidence`, `reasons`, `score_breakdown`, `flags`, `pricing`, `signals` (all raw numbers used), `probe`, `disclosure`, `rules_version`, `checked_at`. Errors come back as a row with `error` set, so a batch never fails because of one bad item.

### Use from AI agents (MCP)

Add it to any MCP client via `https://mcp.apify.com?actors=tudorlane/actor-trust-check`, or call the Apify API / run-sync endpoint.

### FAQ

**Is this an official Apify rating?** No. It's an independent score from Apify's public data. Apify's own Store badges are shown in `signals.store_badge` when present.

**Why is a brand-new Actor marked caution?** With few runs and users there's little evidence either way. The score leans neutral and `confidence` says **low**; check again after a few weeks.

**Do you score your own Actors more kindly?** No. Same rules, and the output says when the Actor is ours.

**Can it check private Actors?** No, only public ones.

### Honest limits

- Public stats cover all users' runs, including runs that failed because of bad input, so a powerful Actor used in tricky ways can look less reliable than it is.
- Speed and data quality aren't in the public stats; the optional probe gives one run's speed only.
- A probe uses the Actor's example input; it can fail for reasons that aren't the Actor's fault (e.g. it needs your own API key).
- Ratings with fewer than 3 reviews are ignored. Store data can lag by a few hours.

# Actor input Schema

## `requests` (type: `array`):

Each item: "username/actor-name" (or an Actor ID, or an apify.com URL), or {"actor": "username/actor-name"}. Max 100. Errors (e.g. Actor not found or not public) are not charged.

## `probe` (type: `boolean`):

Off by default. If on, we also start ONE short test run of each Actor in YOUR Apify account, using the Actor's own example input, 60 s timeout. Only for free, pay-per-event or pay-per-result Actors whose cost can be capped under max_probe_usd; skipped otherwise (reason shown). A failed probe with no results takes 10 points off.

## `max_probe_usd` (type: `number`):

Most a probe run may cost you per Actor (max $0.05). Pay-per-event probes are hard-capped by Apify's spend limit; free-Actor cost is estimated from memory x 60 s.

## Actor input object example

```json
{
  "requests": [
    "apify/web-scraper",
    "apify/google-search-scraper"
  ],
  "probe": false,
  "max_probe_usd": 0.01
}
```

# Actor output Schema

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

One item per request.

## `dataset` (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 = {
    "requests": [
        "apify/web-scraper",
        "apify/google-search-scraper"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tudorlane/actor-trust-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 = { "requests": [
        "apify/web-scraper",
        "apify/google-search-scraper",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tudorlane/actor-trust-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 '{
  "requests": [
    "apify/web-scraper",
    "apify/google-search-scraper"
  ]
}' |
apify call tudorlane/actor-trust-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tudorlane/actor-trust-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/nodsv2DFkxR8QouGB/builds/QWJxYYeiUsjouJmVX/openapi.json
