# Audit Tools → Score, Benchmark, & Compare Apify Actors (`growth_wizard/audit-tools`) Actor

Which Actor should I use? Audit Tools is Apify actor evaluation with receipts: benchmark, score & compare actors side-by-side on cost, quality & permission posture, or any criteria you define in plain English. 23 built-in are a head start, not a limit. $0.01/1,000, $1 deep scan: audit-tools.ai

- **URL**: https://apify.com/growth\_wizard/audit-tools.md
- **Developed by:** [Cecily Robyn Lough](https://apify.com/growth_wizard) (community)
- **Categories:** Developer tools, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 metadata evaluations

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

## Audit Tools - Compare & Score Apify Actors Before You Buy

Score any Apify actor against any criteria you define in plain English, before you commit to using it. The 23 built-in criteria are a head start, not a limit. Independent, evidence-backed, agent-first. **Measured, not marketed.**

🌐 Full methodology, published audits & live evaluations: [audit-tools.ai](https://audit-tools.ai)

![Sample audit report: per-criterion scores with the evidence behind every number](https://api.apify.com/v2/key-value-stores/pd8wkJ9ct0f6qUymi/records/store-readme-report-sample.png)
*A published audit report: every score comes with the measurement behind it.*

### Why you need it

Picking the wrong actor costs you twice: once in wasted spend, and again when your pipeline breaks on data you trusted. Audit Tools catches that before you commit:

- **Avoid abandoned actors.** The rot check flags listings that no longer build or have gone stale.
- **See real reliability, not marketing.** 30-day success rates from actual run data, with the evidence behind every number.
- **Compare before you buy.** Score 4 competing scrapers head to head and pick with numbers instead of screenshots.
- **Screen for agent-readiness.** Know whether an actor can sit in an autonomous pipeline at all (permission posture, pay-per-event pricing, x402 eligibility) before you wire it in.
- **Audit your own listing.** Publishers: find out what is dragging your ranking down before Apify AI passes you over for a competitor.

### What you get

Give it one or more actor IDs. For each actor you get back:

- **Overall score** from 0 to 100 across your chosen criteria
- **Verdict**: Recommended, Acceptable, or Avoid
- **Per-criterion breakdown**: reliability, documentation quality, pricing transparency, input schema completeness, agent-readiness, and more
- **Evidence for every score**: the data behind the number, not just a rating

### Pricing

**Metadata evaluation is effectively free at $0.01 per 1,000. Deep scan is $1.00 per actor evaluated.**

New to Apify? The free plan includes $5 of monthly credit, which now covers thousands of metadata evaluations, so you can audit your entire shortlist before spending anything. You are charged once per successfully evaluated actor, nothing for failures.

### When to use this

- Comparing multiple actors for the same task (e.g. 4 TikTok scrapers)
- Before building a pipeline that depends on an actor you haven't used
- Re-auditing actors you already depend on
- Screening an actor for agent-readiness before wiring it into an autonomous pipeline

### Any criteria. The 23 built-in are a head start, not a limit

**Metadata criteria** (no execution of the target): rot check (does it still exist and build), 30-day reliability, freshness, x402 payability, permission posture (full-permission actors are an agent-pipeline blocker), pricing transparency, publisher pulse, user trajectory, documentation quality, input schema completeness, and more.

**Deep-scan criteria** (live probes on real inputs, via [audit-tools.ai/evaluate](https://audit-tools.ai/evaluate)): advertised-field truth, cost per usable item, end-to-end latency, memory fit, run-to-run consistency, README structure, and quality delta across repeat audits.

Full rubric with one-paragraph definitions: [audit-tools.ai/criteria](https://audit-tools.ai/criteria). You can also define **custom criteria** in plain English and have any actor scored against what actually matters to you: [audit-tools.ai/rubrics](https://audit-tools.ai/rubrics).

### Why this over metadata-only scorers?

Most actor-quality tools score the listing: stats, user counts, description quality. Audit Tools covers the full 41,000+ actor store and, in deep-scan mode, **runs the actor on real inputs and scores what comes back**, with an evidence receipt behind every number. It is also the only evaluator that scores the agent-economy criteria (x402 payability and permission posture) that decide whether an actor can sit in an autonomous pipeline at all. Published, dated audit reports live at [audit-tools.ai/tools](https://audit-tools.ai/tools).

### No human approval, anywhere

This actor runs with **limited permissions** (it can never touch your account data) and meets [Apify's x402 eligibility rules](https://docs.apify.com/platform/integrations/x402): pay-per-event pricing, limited permissions, no Standby. That means an autonomous agent can discover it and run it end to end with zero sign-off steps. No permission approval screen, no human in the loop.

### Example: compare the four TikTok scrapers

We audited all four clockworks TikTok scrapers the morning Apify unified their pricing (June 30, 2026). Score spread: 71 to 84. Price parity is not quality parity. [Read the full audit](https://audit-tools.ai/blog/tiktok-actors-june-2026.html). The exact input for that comparison is in the developer section below.

### First-run FAQ

**Which mode should I start with?** `metadata`. It is effectively free at $0.01 per 1,000 actors and covers the criteria that catch most bad picks (rot, reliability, permission posture), so you can screen a whole shortlist before spending anything.

**Do I need any special permissions?** No. This is a limited-permission actor; there is no first-run human approval step.

**What does an empty or partial result mean?** An invalid actor ID throws an error naming the target. If one target in a batch fails, you are only charged for the ones that succeeded.

**Why does my billing not show charges immediately?** Apify's billing counters can lag a few minutes behind the run.

**Where are deep scans?** Live-probe deep scans run via [audit-tools.ai/evaluate](https://audit-tools.ai/evaluate) today (from $0.20) and are coming to this actor as a paid event ($1.00/actor). Until then, selecting **Full audit** in the mode dropdown returns those buying details and charges you nothing.

### Rank higher in Apify AI and Store search

Apify AI (launched July 2026) recommends Actors based on three things: a strong Actor quality score, a clear README, and well documented input and output schemas. Those are exactly what Audit Tools measures. Run an actor evaluation on your own Actor to see which signals are holding it back before Apify AI passes it over for a competitor.

### Use cases: audit actors, evaluate tools, score actor quality

- **Audit actors before you buy**: audit actors and evaluate tools with a full evidence trail, so you never build on a listing you have not measured
- **Tool evaluation for AI agents**: score any Apify Actor against your own criteria (23 built-in included) before an agent spends money on it
- **Actor scoring for publishers**: audit your own listing (README quality, schema completeness, reliability, pricing transparency) and fix what lowers your ranking
- **Actor comparison / tool comparison**: head to head scoring of two or more Actors solving the same problem, with evidence for every number
- **Web scraper evaluation**: reliability, rot check, and cost per item for scrapers before you build on them
- **MCP and x402 readiness check**: is this Actor payable by autonomous agents (Pay Per Event, agentic payment whitelist, permission posture)?

***

### For developers & agents: schemas, costs, and a smoke test

Everything below is reference material for programmatic use. If you just want to evaluate an actor, use the input form above.

#### Input schema

```json
{
  "targets": ["clockworks/tiktok-scraper", "clockworks/tiktok-profile-scraper"],
  "mode": "metadata"
}
```

- `targets` (required): 1-10 actor IDs in `username/actor-name` format.
- `mode`: `"metadata"` (default, $0.01 per 1,000 actors), `"estimate"` (cost preview only, no probes, never billed), or `"full"` (not sold through this listing: returns a note telling you where to buy the live-probe audit, and is never billed).

#### Output record (one per actor, pushed to the dataset)

```json
{
  "actorId": "clockworks/tiktok-profile-scraper",
  "actorTitle": "TikTok Profile Scraper",
  "overallScore": 84,
  "verdict": "Recommended",
  "scores": [
    { "criterion": "reliability-30d", "score": 92, "evidence": "312/318 runs succeeded in the last 30 days" },
    { "criterion": "pricing-transparency", "score": 88, "evidence": "PPE events documented with prices in README" }
  ],
  "mode": "metadata",
  "evaluatedAt": "2026-07-22T14:03:11.000Z",
  "evaluationId": "ev_abc123"
}
```

Fields an agent can branch on:

- `verdict` is a stable enum: `Recommended` (score >= 80), `Acceptable` (60-79), `Avoid` (below 60).
- `overallScore` is always 0-100. Per-criterion `score` values are also 0-100.
- A failed target throws with a descriptive error rather than returning a silent empty record.

#### Cost formula

```
cost = (number of targets) x (event price for the mode)
metadata:  N x $0.00001
deep scan: N x $1.00
estimate:  $0 - never billed
```

#### Smoke test (cheapest possible first run)

Run this exact input, one metadata evaluation of a well-known actor:

```json
{ "targets": ["apify/website-content-crawler"], "mode": "metadata" }
```

Expected: one dataset record with `overallScore` (0-100), a `verdict` from the enum above, and a non-empty `scores` array with evidence strings. Expected cost: **$0.00001**, effectively free and comfortably inside Apify's free plan credit. If your integration parses that record, you're done.

#### The TikTok comparison input

```json
{
  "targets": [
    "clockworks/tiktok-scraper",
    "clockworks/tiktok-profile-scraper",
    "clockworks/tiktok-hashtag-scraper",
    "clockworks/tiktok-video-scraper"
  ],
  "mode": "metadata"
}
```

#### Run it from Claude, Cursor, LangChain, or curl

Agents can run Audit Tools through Apify's official MCP server or plain HTTP. A free smoke test is built in: set `"mode": "estimate"` and the run costs nothing.

**Claude Desktop / Claude Code / Cursor (MCP).** Add this to your MCP config (`claude_desktop_config.json`, `.mcp.json`, or Cursor's MCP settings). Replace `YOUR_APIFY_TOKEN` with your token from Apify Console:

```json
{
  "mcpServers": {
    "audit-tools": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://mcp.apify.com/?tools=growth_wizard/audit-tools",
        "--header", "Authorization: Bearer YOUR_APIFY_TOKEN"
      ]
    }
  }
}
```

Then ask your agent: "Use audit-tools to evaluate apify/instagram-scraper in estimate mode." That first call is free.

**Plain curl (Apify API):**

```bash
curl -X POST "https://api.apify.com/v2/acts/growth_wizard~audit-tools/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"targets": ["apify/instagram-scraper"], "mode": "metadata"}'
```

**LangChain:**

```python
## pip install langchain-apify
from langchain_apify import ApifyActorsTool

tool = ApifyActorsTool("growth_wizard/audit-tools")
result = tool.invoke({
    "run_input": {"targets": ["apify/instagram-scraper"], "mode": "metadata"}
})
```

More agent options, including paying per report with USDC via x402 and no Apify account, at [audit-tools.ai/docs](https://audit-tools.ai/docs). The x402 endpoint is listed in Coinbase's x402 Bazaar, on x402scan, and graded A on x402-list.com.

***

Built by the team behind [audit-tools.ai](https://audit-tools.ai) - independent actor evaluation with a receipt for every score.

***

Audit before you adopt. Monitor after you adopt with [Datasource Pulse](https://apify.com/growth_wizard/datasource-pulse) - Actor, API and scraper health monitoring from the same maker. Also from us: [Demand Discovery AI™](https://demanddiscovery.ai/).

# Actor input Schema

## `targets` (type: `array`):

One or more actor IDs in username/actor-name format, up to 5 per run. The limit of 5 is a total for the whole run, not a limit for each actor. Example: clockworks/tiktok-scraper

## `mode` (type: `string`):

Choose metadata for a scored evaluation (USD 0.00001 per actor, effectively free), or estimate for a free cost preview with no probes run. The full audit is not sold through this listing: it runs each target actor for real to measure cost per item, latency, memory fit, run consistency and whether the advertised output fields actually appear. Select it below to see how to buy it, or go straight to https://audit-tools.ai/api/evaluations (USD 1.00 per actor, payable by an agent over x402, no account needed).

## Actor input object example

```json
{
  "targets": [
    "apify/instagram-scraper"
  ],
  "mode": "estimate"
}
```

# 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 = {
    "targets": [
        "apify/instagram-scraper"
    ],
    "mode": "estimate"
};

// Run the Actor and wait for it to finish
const run = await client.actor("growth_wizard/audit-tools").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 = {
    "targets": ["apify/instagram-scraper"],
    "mode": "estimate",
}

# Run the Actor and wait for it to finish
run = client.actor("growth_wizard/audit-tools").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 '{
  "targets": [
    "apify/instagram-scraper"
  ],
  "mode": "estimate"
}' |
apify call growth_wizard/audit-tools --silent --output-dataset

```

## MCP server setup

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

```

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/B1INg9XBxNuC5EKr5/builds/FvgpcGgzzIrxdkf4E/openapi.json