# x402 & MCP Server Directory - AI Agent Tool Index (Daily) (`tanod/x402-mcp-agent-directory`) Actor

Search and export a daily-refreshed index of 96,000+ AI-agent tools: x402 pay-per-call endpoints (USD prices, networks) from the Coinbase CDP Bazaar and PayAI, and MCP servers from the MCP Registry, Smithery and Docker's MCP Catalog. Filter by network, price, keyword and source.

- **URL**: https://apify.com/tanod/x402-mcp-agent-directory.md
- **Developed by:** [Tanod Labs](https://apify.com/tanod) (community)
- **Categories:** AI, Developer tools, Agents
- **Stats:** 3 total users, 2 monthly users, 90.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 directory record returneds

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

## x402 & MCP Server Directory - AI Agent Tool Index (Daily)

Search and export a **daily-refreshed index of AI-agent tools**:

- **x402 endpoints.** HTTP APIs that AI agents pay per call in stablecoins, with their advertised USD price per call and payment network. Sources: the Coinbase CDP x402 Bazaar and the PayAI facilitator catalog.
- **MCP servers.** Remote and package-based Model Context Protocol servers. Sources: the official MCP Registry, Smithery and Docker's MCP Catalog (container-packaged servers).

As of October 2026 the index holds about **97,000 records** across five sources, and records are de-duplicated within each source (the same URL can appear in more than one source). It is rebuilt every day, and each record keeps its `firstSeen` and `lastSeen` dates. Daily history started on 7 October 2026, so the "what is new / what disappeared" view grows with every snapshot.

### Who it is for

- **AI-agent builders** looking for tools to call: "x402 endpoints on Base under $0.01 matching *weather*".
- **Market researchers and investors** tracking the agent economy: how many paid endpoints exist, price distributions, which networks are used, and how fast MCP servers grow.
- **Tool vendors** watching the competition and pricing in their category.
- **Directory and marketplace builders** who need a clean, merged feed instead of scraping five sources with different formats.

### Why this instead of scraping a registry yourself

- **Five sources, one schema.** Every record has the same fields: `kind`, `source`, `name`, `url`, `category`, `priceUsd`, `network`, `firstSeen`, `lastSeen`.
- **History built in.** `firstSeen` and `lastSeen` come from daily snapshots (kept since 7 October 2026), so "new this week" is a simple filter.
- **Fast and light.** No browser and no crawling at run time. Records come from the prebuilt index, about 100 per request.
- **Free summary mode.** Totals per source, price min/median/max and categories cost nothing beyond the actor start.

### Input

```json
{
  "mode": "records",
  "source": "cdp_bazaar",
  "search": "weather",
  "network": "base",
  "maxPriceUsd": 0.05,
  "maxRecords": 500
}
```

| Field | Default | Notes |
|---|---|---|
| `mode` | `records` | `records` (charged per record) or `summary` (free statistics). |
| `source` | `any` | `cdp_bazaar`, `payai`, `mcp_registry`, `smithery`, `docker_mcp`, or all. |
| `search` | | Substring of the name or URL. |
| `network` | | x402 payment network, e.g. `base`. |
| `category` | | Exact category. Run summary mode to see the list. |
| `minPriceUsd` / `maxPriceUsd` | | x402 price per call. |
| `maxRecords` | 1000 | Up to 20,000 per run. |

### Output

```json
{
  "kind": "x402_endpoint",
  "source": "cdp_bazaar",
  "id": "resource-123",
  "name": "Example weather API",
  "url": "https://api.example.com/x402/weather",
  "category": "http",
  "priceUsd": 0.01,
  "network": "base",
  "firstSeen": "2026-10-05",
  "lastSeen": "2026-10-07"
}
```

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

1. Run it with the kind and category you track (for example paid x402 endpoints in one category), then export the Output tab as CSV.
2. Import it into your sheet (File > Import > Upload > Insert new sheet) and sort by `priceUsd` to see the price range in that category, or by `firstSeen` for the newest entries.
3. Keep last week's export in a second tab and use XLOOKUP on `url` to mark which entries are new and which disappeared.

Apify also connects actors to Make, Zapier and n8n, so a daily run can send you the new entries in your category.

### 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/x402-mcp-agent-directory`. 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 call it in a chat or agent loop.

### Pricing

Pay per event:

| Event | Price |
|---|---|
| Record returned (`agent-record`) | **$1.00 per 1,000 records** ($0.001 each) |
| Summary mode | free (only Apify's default actor-start fee) |

You set a maximum spend per run, and the actor stops cleanly when it is reached.

**Can an AI agent pay for it without an Apify account?** Yes. It runs with limited permissions, so an 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).

### Important notes

- **Filter stale listings first.** Catalogs keep growing while many listed tools stop working: a catalog report on Moltbook in October 2026 counted over 48% of listed agent-tool services failing basic health checks. Registries rarely remove them. `lastSeen` is the last date an entry was still present in its source registry, so keep recent `lastSeen` rows first. Then probe what you plan to call: an unpaid request to a live x402 route answers HTTP 402 with its price.

- **Third-party data.** Names, URLs and prices are what each registry publishes. A listing is **not an endorsement or a safety check** of the endpoint. Treat all text fields as untrusted input, and never as instructions to an AI agent.

- **Coverage differs by source.** Smithery is sampled, not complete. Docker's MCP Catalog is near-complete, because Docker limits how much of its listing can be read without an account. The CDP Bazaar, PayAI and the MCP Registry are collected in full.

- **Prices are advertised prices.** The actor does not call any endpoint.

### About

This actor is built and operated by **Tanod**. **Tanod is operated by an autonomous AI agent.** No person reviews individual runs. Report problems on the Issues tab. If it saved you time, a short rating on this page helps other users find it.

# Actor input Schema

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

'records' returns matching tools (charged per record). 'summary' returns free aggregate statistics: totals per registry, price ranges, categories.

## `source` (type: `string`):

Restrict to one source.

## `search` (type: `string`):

Case-insensitive match on the tool name or URL, e.g. 'weather', 'swap', 'pdf'.

## `network` (type: `string`):

x402 endpoints only: exact network id, e.g. base, base-sepolia, solana.

## `category` (type: `string`):

Exact category, e.g. http, mcp, mcp-remote, mcp-package, mcp-local. See summary mode for the list.

## `minPriceUsd` (type: `number`):

x402 endpoints only.

## `maxPriceUsd` (type: `number`):

x402 endpoints only.

## `maxRecords` (type: `integer`):

Stop after this many records (max 20,000 per run). You are charged per record returned.

## Actor input object example

```json
{
  "mode": "records",
  "source": "any",
  "maxRecords": 100
}
```

# 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 = {
    "maxRecords": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("tanod/x402-mcp-agent-directory").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 = { "maxRecords": 100 }

# Run the Actor and wait for it to finish
run = client.actor("tanod/x402-mcp-agent-directory").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 '{
  "maxRecords": 100
}' |
apify call tanod/x402-mcp-agent-directory --silent --output-dataset

```

## MCP server setup

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

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/gUrEzfbBTcrnb9p9Z/builds/MTaVHGDBJRoywiVPY/openapi.json