# MCP & x402 Readiness Auditor (`wintry_nutmeg/mcp-x402-readiness-monitor`) Actor

Validate remote MCP tools and x402 seller discovery, pricing, and payment readiness before autonomous agents spend money.

- **URL**: https://apify.com/wintry\_nutmeg/mcp-x402-readiness-monitor.md
- **Developed by:** [Dries Vd](https://apify.com/wintry_nutmeg) (community)
- **Categories:** Developer tools, AI, Agents
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 mcp and x402 seller audits

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does MCP & x402 Buyer Readiness Monitor do?

**MCP & x402 Buyer Readiness Monitor validates agent services before autonomous buyers spend money.** Give it a seller URL and it performs a real MCP initialization handshake, discovers available tools, inspects the x402 discovery document, checks prices and payment networks, and returns a compact readiness score. Run it through Apify's API, connect it to workflows, schedule recurring checks, or monitor many vendors in one request.

The Actor is designed for AI-agent developers, marketplaces, procurement agents, and x402 sellers. It produces structured evidence—not vague claims—so downstream agents can decide whether a service is technically safe to attempt.

### Why use MCP & x402 Buyer Readiness Monitor?

- Prevent wasted paid calls to broken or incomplete agent endpoints.
- Discover MCP tools and their input schemas automatically.
- Verify that x402 prices and blockchain networks are explicitly advertised.
- Monitor vendor readiness over time and detect regressions.
- Compare up to 20 sellers in a single API request.
- Feed normalized JSON into autonomous purchasing and routing workflows.

### How to use MCP & x402 Buyer Readiness Monitor

1. Start the Actor in Standby mode.
2. Send a POST request to `/audit` on its Standby URL.
3. Provide one `url` or an array named `urls`.
4. Read the score, failed checks, discovered tools, prices, and recommendation.
5. Schedule the same request when you need continuous vendor monitoring.

### Input

```json
{ "url": "https://agent-revenue-auditor.vandurmedries.workers.dev" }
```

For comparison, send `{"urls":["https://seller-one.example","https://seller-two.example/mcp"]}`. Only public HTTP(S) endpoints are accepted. A batch can contain at most 20 URLs.

### Output

```json
{
  "target": "https://seller.example",
  "ready": true,
  "score": 100,
  "grade": "A",
  "checks": { "mcpHandshake": true, "toolsDiscoverable": true, "x402Discovery": true, "explicitPrices": true, "paymentNetwork": true },
  "mcp": { "toolCount": 3, "latencyMs": 118 },
  "recommendation": "Ready for autonomous buyers."
}
```

Results are also pushed to the default dataset. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

| Field | Meaning |
| --- | --- |
| `score` | Readiness score from 0 to 100 |
| `checks` | Five independently verifiable buyer checks |
| `tools` | MCP tool names, descriptions, and schemas |
| `x402.endpoints` | Advertised paid routes, prices, and networks |
| `latencyMs` | Observed response time during this run |
| `checkedAt` | ISO timestamp for monitoring and comparisons |

### Pricing / Cost estimation

This Actor is optimized for inexpensive HTTP checks and does not launch a browser. One request can audit up to 20 sellers, making batch monitoring more cost-efficient than separate crawls. Actual Store pricing is shown before each run; network latency and the number of targets determine runtime.

### Advanced options

Use a seller's origin URL when MCP is hosted at `/mcp`, or provide the full MCP URL. Schedule a daily batch to detect outages, removed tools, changed schemas, or price/network changes. Treat the result as technical due diligence—not as a guarantee that a seller's content or business claims are correct.

### FAQ, disclaimers, and support

The monitor only accesses public endpoints and never signs payments. It does not purchase products or expose paid results. Some MCP services require authentication and will correctly score as unavailable to anonymous buyers. Respect every target's terms and access policies. For bugs, edge cases, or custom marketplace integrations, use the Actor's Issues tab.

# Actor input Schema

## `url` (type: `string`):

Public HTTP(S) origin or full /mcp endpoint to validate.

## `urls` (type: `array`):

Audit up to 20 seller origins in one request. The Standby POST /audit endpoint accepts this field.

## Actor input object example

```json
{
  "url": "https://agent-revenue-auditor.vandurmedries.workers.dev"
}
```

# Actor output Schema

## `audits` (type: `string`):

Machine-readable protocol checks, discovered tools, prices, and recommendations.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("wintry_nutmeg/mcp-x402-readiness-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("wintry_nutmeg/mcp-x402-readiness-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 '{}' |
apify call wintry_nutmeg/mcp-x402-readiness-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,wintry_nutmeg/mcp-x402-readiness-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/Xe0fiXXYPzbXCY0NL/builds/BfSAAKlePzidDwVUY/openapi.json