Deterministic webpage change detection, hashes and text diffs for recurring monitoring via x402 MCP.
Scored across 5 tools
The five tools have mostly distinct resource/action targets: aborting runs, inspecting runs, reading dataset rows, reading key-value records, and invoking the website-change Actor. Slight ambiguity exists between get-dataset-items and the domain Actor tool because both can return output/results, but descriptions clarify their different scopes.
Four tools use a readable kebab-case verb-resource pattern (abort-actor-run, get-actor-run, get-dataset-items, get-key-value-store-record). However, the core domain tool uses an entirely different Actor-slug convention with underscores and double hyphens, breaking the pattern significantly.
Five tools is a reasonable count for a server wrapping an Actor with operational helpers. The set is not bloated, but most tools are generic Apify infrastructure rather than domain-specific website-monitoring operations.
The surface covers invoking the website-change Actor, checking/aborting runs, and retrieving dataset and key-value outputs. It lacks explicit listing or management operations for monitors, datasets, or stores, but the main Actor tool likely handles the core comparison workflow.
Abort an Actor run that is currently starting or running. For runs with status SUCCEEDED, FAILED, ABORTING, ABORTED, or TIMED-OUT, this call has no effect. The results will include the updated run details after the abort request.
USAGE:
Use when you need to stop a run that is taking too long or misconfigured.
USAGE EXAMPLES:
user_input: Abort run y2h7sK3Wc
user_input: Gracefully abort run y2h7sK3Wc
This tool requires an x402 payment. Include a valid x402 payment signature in the request metadata (_meta["x402/payment"]). Your MCP client must support the x402 payment protocol.
| Name | Required | Description | Default |
|---|---|---|---|
| runId | Yes | The ID of the Actor run to abort. | |
| gracefully | No | If true, the Actor run will abort gracefully with a 30-second timeout. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructive=true, idempotent=true and openWorld=false, yet the description still adds real value: terminal-state no-op behavior, the fact that updated run details are returned, and a required x402 payment signature in _meta. The payment/auth prerequisite is exactly the kind of operational context the schema cannot convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Well front-loaded: the core action and state constraint come first, followed by no-op conditions, usage, and payment prerequisites. The labeled USAGE/USAGE EXAMPLES blocks with 'user_input:' lines are slightly redundant padding, costing it the top mark.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need no elaboration, and annotations cover the safety profile. Combined with the description's state preconditions and the x402 payment requirement, an agent has everything needed to call this correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so runId and gracefully are already fully documented, including the 30-second graceful timeout. The description's example ('Gracefully abort run y2h7sK3Wc') implies the flag but adds no syntax or format detail beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Abort) applied to a specific resource (Actor run) and narrows the scope to runs 'currently starting or running'. This is clearly distinguishable from the read-oriented siblings like get-actor-run and get-dataset-items.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to reach for it ('stop a run that is taking too long or misconfigured') and when it is a no-op (runs already SUCCEEDED, FAILED, ABORTING, ABORTED, or TIMED-OUT). The when-not condition is unusually precise and prevents wasted calls.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific Actor run.
Returns run result: status, storages (datasets/keyValueStores alias map), stats, summary, nextStep.
summary describes the past (e.g. "SUCCEEDED in 22s. 47 items; 3 fields available.").
nextStep prescribes one primary follow-up action with identifiers interpolated (e.g. "Use get-dataset-items with datasetId=...").
waitSecs (0–45, default 30) waits up to that many seconds for terminal status before returning.
USAGE:
Use to check the status of a run started by any Actor-running tool.
Pass waitSecs > 0 to block until terminal (or until the cap elapses).
USAGE EXAMPLES:
user_input: Show details of run y2h7sK3Wc
user_input: Wait for run y2h7sK3Wc to finish
This tool requires an x402 payment. Include a valid x402 payment signature in the request metadata (_meta["x402/payment"]). Your MCP client must support the x402 payment protocol.
| Name | Required | Description | Default |
|---|---|---|---|
| runId | Yes | The ID of the Actor run. | |
| waitSecs | No | Maximum seconds to wait for the run to reach a terminal state (SUCCEEDED, FAILED, ABORTED, TIMED-OUT). 0 returns immediately with the current status. Cap: 45. Default: 30. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the annotations by disclosing a hard prerequisite the structured fields cannot express: an x402 payment signature must be supplied in _meta, or the call fails. It also explains the blocking semantics of waitSecs and what summary/nextStep contain, which is real behavioral context on top of readOnlyHint/idempotentHint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Well front-loaded: the purpose leads, followed by return contents, usage, and examples under clear labels. It is somewhat longer than necessary — the two user_input examples largely restate the usage bullets — but nothing is genuinely wasteful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although an output schema exists (so return shapes need no explanation), the description still clarifies what summary and nextStep mean, covers the blocking behavior, and surfaces the payment requirement. An agent has everything needed to call it correctly on the first attempt.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and both parameters are already fully documented in the schema, including waitSecs' range, default, and terminal-state list. The description restates waitSecs (0-45, default 30, blocks until terminal) but adds no syntax or format detail beyond it, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Get detailed information about a specific Actor run') and immediately enumerates the returned fields (status, storages, stats, summary, nextStep). This is clearly distinguishable from the mutation sibling abort-actor-run and from the storage readers get-dataset-items / get-key-value-store-record.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit trigger ('Use to check the status of a run started by any Actor-running tool') and conditional behavior for waitSecs > 0. It does not name when NOT to use it or point to an alternative tool for cancelling/waiting differently, so it stops short of full when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get items (rows) from a dataset — the output/results produced by an Actor run. Returns the rows themselves, not dataset metadata, counts, or a schema. When the user provides a datasetId and asks to retrieve results, output, data, or rows, call this tool directly. Default limit is 20. Use clean=true to skip empty items and hidden fields.
USAGE:
Use when you need to read data from a dataset (all items or only selected fields).
USAGE EXAMPLES:
user_input: Retrieve results from dataset abc123
user_input: Get only metadata.url and title from dataset username~my-dataset
This tool requires an x402 payment. Include a valid x402 payment signature in the request metadata (_meta["x402/payment"]). Your MCP client must support the x402 payment protocol.
| Name | Required | Description | Default |
|---|---|---|---|
| desc | No | If true, results are returned in reverse order (newest to oldest). | |
| omit | No | Comma-separated list of fields to exclude from results. | |
| clean | No | If true, returns only non-empty items and skips hidden fields (starting with #). Shortcut for skipHidden=true and skipEmpty=true. | |
| limit | No | Maximum number of items to return. Default is 20. | |
| fields | No | Comma-separated list of fields to include in results. Fields in output are sorted as specified. Use dot notation for nested objects (e.g. "metadata.url"); the server auto-flattens parent prefixes. | |
| offset | No | Number of items to skip at the start. Default is 0. | |
| flatten | No | Comma-separated list of fields to flatten (e.g. flatten="metadata" turns {"metadata":{"url":"x"}} into {"metadata.url":"x"}). Normally derived automatically from dot-notation in `fields`; specify only as a diagnostic override. | |
| datasetId | Yes | Dataset ID, name (resolved against your own datasets), or full name as username~name. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior. The description adds important non-annotation context: the tool requires an x402 payment signature in request metadata, plus default limit and clean=true behavior. It does not discuss error modes or rate limits, so it is strong but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose and return distinction, then follows with usage and examples. It is generally efficient, though some statements such as default limit and clean behavior duplicate the schema, and the separate usage/examples sections add slight redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the rich annotations, 100% schema description coverage, and an output schema, the description provides everything needed for correct invocation. It covers purpose, return semantics, usage context, default behavior, and the critical x402 payment requirement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 8 parameters, including default limit, clean behavior, fields/omit/flatten semantics, and datasetId resolution. The description reinforces a few of these and gives example field selections, but adds little parameter semantics beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource ('Get items (rows) from a dataset') and clarifies exactly what is returned versus what is not (metadata, counts, schema). It also gives the direct-call condition when the user provides a datasetId and asks for results, so an agent can distinguish this from adjacent dataset operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states when to use the tool ('when you need to read data from a dataset') and provides concrete user-input examples. It also excludes metadata/count/schema use cases, but it does not name alternative tools for those adjacent needs, so it falls short of full when/when-not/alternatives guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the value stored under a specific key in a key-value store — a single record, not a listing of all keys. Requires the exact key name. The response preserves the original Content-Encoding; most clients handle decompression automatically.
USAGE:
Use when you need to retrieve a specific record (JSON, text, or binary) from a store.
USAGE EXAMPLES:
user_input: Get record INPUT from store abc123
user_input: Get record data.json from store username~my-store
This tool requires an x402 payment. Include a valid x402 payment signature in the request metadata (_meta["x402/payment"]). Your MCP client must support the x402 payment protocol.
| Name | Required | Description | Default |
|---|---|---|---|
| recordKey | Yes | Key of the record to retrieve. | |
| keyValueStoreId | Yes | Key-value store ID, name (resolved against your own key-value stores), or full name as username~name. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly/idempotent annotations, the description discloses that the exact key name is mandatory, that the response preserves the original Content-Encoding with most clients decompressing automatically, and — critically — that the call requires an x402 payment signature in _meta["x402/payment"] and client-side protocol support. These are material behavioral facts no annotation or schema field conveys.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core purpose, then sectionalized USAGE, examples, and the payment prerequisite. Every line carries information, though the header scaffolding and duplicated phrasing between the purpose line and USAGE line cost a bit of tightness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description need not explain return values and correctly doesn't. It covers the one thing an agent would otherwise trip on — the x402 payment handshake — and the encoding caveat, leaving nothing essential unstated for a two-parameter read.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents both parameters and establishes a baseline of 3. The description adds one genuinely extra constraint — the key must be an exact name, implying no prefix or wildcard matching — which slightly raises it above baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Get the value stored under a specific key in a key-value store') and immediately bounds the scope with 'a single record, not a listing of all keys.' The read-vs-list distinction lets an agent separate it from any collection-listing tool without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
An explicit USAGE line plus two concrete examples ('Get record INPUT from store abc123', 'data.json from store username~my-store') show exactly when the tool applies. There is no named negative case or alternative tool to route away to, which keeps it below a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
This tool calls the Actor "industrial_platform/web-change-intelligence" and retrieves its output results. Actor description: Website change detector and deterministic diff API for AI agents. Monitor pricing, availability, documentation, policies, and competitor pages. $0.001 per successful comparison.
This tool requires an x402 payment. Include a valid x402 payment signature in the request metadata (_meta["x402/payment"]). Your MCP client must support the x402 payment protocol.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | **REQUIRED** Public http:// or https:// URL to inspect. Example values: "https://example.com/" | |
| selector | No | Optional CSS selector that restricts monitoring to a specific part of an HTML page, such as main, #pricing, or .inventory. | |
| waitSecs | No | Max seconds (0–45, default 30) to cap the wait for the Actor run to reach terminal state. For long-running Actors the response returns at the cap with the current run status; follow `nextStep` to poll via get-actor-run. Set to 0 to fire-and-forget. | |
| previous_hash | No | Optional current_hash from a previous run. Use this for compact changed/unchanged checks when a detailed diff is not required. | |
| previous_text | No | Optional current_text returned by a previous run. When provided, the Actor returns deterministic added/removed excerpts and change metrics. | |
| max_diff_chars | No | Maximum length returned for each added/removed excerpt. Example values: 12000 | |
| max_text_chars | No | Maximum characters retained before hashing and comparison. Keep this value consistent across repeated checks. Example values: 100000 | |
| timeout_seconds | No | Maximum time allowed for the target request. Example values: 30 | |
| ignore_selectors | No | Optional HTML selectors to remove before comparison, useful for clocks, rotating banners, ads, or other volatile regions. | |
| include_current_text | No | Return current_text so a later run can perform a detailed text comparison. Example values: true |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, so the agent already knows this is a non-read-only, potentially destructive, open-world operation. The description adds valuable context: x402 payment is required via _meta["x402/payment"] and the client must support the protocol. It does not explain what 'destructive' means here or what side effects (writes, cost) occur beyond pricing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short but mixes three things: tool mechanics, Actor marketing blurb with a price, and the x402 protocol requirement. The pricing sentence ('$0.001 per successful comparison') is somewhat promotional. The payment prerequisite is front-loadable but appears after the Actor marketing line.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return-value explanation is not required. However, the tool is a wrapping Actor call with a required payment protocol and destructiveHint=true, and the description does not clarify the relationship to sibling run/dataset tools, nor the cost model implications. It is minimally complete but leaves gaps for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 10 parameters thoroughly, including url, selector, waitSecs, previous_hash, previous_text, and diff/text char limits. The description adds no parameter-level detail beyond naming the x402 meta key. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb and resource: it calls the Actor 'industrial_platform/web-change-intelligence' and retrieves its output. The Actor description adds a concrete capability — 'Website change detector and deterministic diff API' for monitoring pricing, availability, docs, and competitor pages. That distinguishes it well from generic run tools, though it's framed as an Actor-invocation rather than stating the underlying task directly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (detecting website changes, monitoring pages) but does not explicitly say when to use this versus siblings like get-actor-run or get-dataset-items. The x402 payment note gives a prerequisite, but conditional routing guidance ('use this when you need a diff, not just a fetch') is absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Evidence-bearing public webpage monitoring with hashes, diffs, signed webhooks, REST, and MCP.
Watch a public web page for changes when your agent cannot stay running. Hourly checks, signed diffs
Monitor web pages for price, stock or text changes; low-noise alerts via MCP, API and webhooks.
Website change monitor MCP: see what changed on any public page. Free 3 pages; $4.99/mo.
Add one secure layer between your agents and this server.