# Agent Skills & MCP Server Directory: skills.sh & Smithery (`api-co/agent-skills-mcp-directory`) Actor

G2 for AI agent skills: rank Claude Code / Codex / Cursor agent skills and MCP servers by installs, usage, stars and security audits. Scrapes the skills.sh leaderboard (installs, weekly trend, Snyk/Socket audits), Smithery (usage, tools) and the official MCP Registry (new servers, npm downloads).

- **URL**: https://apify.com/api-co/agent-skills-mcp-directory.md
- **Developed by:** [Emilio Cisneros](https://apify.com/api-co) (community)
- **Categories:** AI, MCP servers, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 skill or mcp servers

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

## Agent Skills & MCP Server Directory: skills.sh & Smithery

**G2 for AI agent skills.** Find the best **agent skills** (Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf) and **MCP servers** in one run. Each one is ranked by real adoption data: **installs**, **8-week install trend**, **Smithery usage**, **npm downloads** and **GitHub stars**. **Security audit verdicts** from Gen Agent Trust Hub, Socket and Snyk act as the "reviews".

Sources:

- **skills.sh**, the open agent-skills directory: all-time, trending and hot leaderboards (top 600 each) and each skill's page.
- **Smithery**, the largest MCP server marketplace: usage count, verified flag, remote/hosted status and the full **tool list** of each server.
- **The official MCP Registry** (registry.modelcontextprotocol.io): newly published servers, packages (npm/PyPI/Docker), remotes, repositories, plus **npm weekly downloads**.

### What you can do with it

- **Pick the right skill or MCP server**: compare options for a task (`postgres`, `browser`, `stripe`, `seo`) by adoption and security, before you install anything.
- **Track the agent ecosystem**: the top and fastest-growing skills each week, and new MCP servers as they are published.
- **Market and competitor research**: see who publishes the most-installed skills and servers (Vercel, Anthropic, Supabase, Microsoft...) and how fast they grow.
- **Security review**: filter skills whose audits returned `warn` or `fail` before rolling them out to a team.
- **Build a directory, newsletter or dashboard**: clean JSON with stable IDs, ready for Sheets, Airtable or a database.

### How to use

1. Optionally add **search terms**, e.g. `postgres`, `react`, `browser`. Leave empty for the top-ranked lists.
2. Choose **sources** and the **skills.sh leaderboard** (all-time, trending or hot).
3. Click **Start**, then export JSON, CSV or Excel, or connect Make, Zapier, n8n or Slack.

With an empty input you get the top 50 all-time skills (with details), the top 50 Smithery servers by usage (with tools), and the 50 newest MCP Registry servers from the last 14 days.

### Input example

```json
{
  "searchTerms": ["postgres", "supabase"],
  "sources": ["skills-sh", "smithery", "mcp-registry"],
  "skillsView": "all-time",
  "includeSkillDetails": true,
  "includeMcpTools": true,
  "maxItemsPerSource": 25
}
```

### Output

**Agent skill** (skills.sh):

```json
{
  "itemType": "agentSkill", "source": "skills.sh", "leaderboard": "all-time", "rank": 1,
  "id": "vercel-labs/skills/find-skills", "name": "find-skills", "owner": "vercel-labs",
  "repositoryUrl": "https://github.com/vercel-labs/skills",
  "url": "https://www.skills.sh/vercel-labs/skills/find-skills",
  "installs": 4017447, "isOfficial": true,
  "weeklyInstalls": [102581, 101561, 101317, 105144, 103601, 107199, 110524, 121189],
  "weeklyInstallsLatest": 121189, "weeklyInstallsChangePct": 9.6,
  "description": "Helps users discover and install agent skills when they ask questions like...",
  "summary": "Discover and install specialized agent skills from the open ecosystem...",
  "tags": ["Agent workflows"], "githubStars": 36200, "firstSeen": "2026-01-26",
  "securityAudits": [
    { "provider": "Gen Agent Trust Hub", "status": "pass" },
    { "provider": "Socket", "status": "pass" },
    { "provider": "Snyk", "status": "warn" }
  ],
  "securityVerdict": "warn",
  "installCommand": "npx skills add https://github.com/vercel-labs/skills --skill find-skills"
}
```

**MCP server** (Smithery):

```json
{
  "itemType": "mcpServer", "source": "smithery", "rank": 1,
  "id": "brave", "name": "Brave Search", "description": "Search the web with Brave's independent index...",
  "url": "https://smithery.ai/server/brave", "useCount": 87579, "verified": true, "remote": true,
  "toolCount": 8, "tools": [{ "name": "brave_web_search", "description": "Performs web searches..." }],
  "connectionTypes": ["http"]
}
```

**MCP server** (official MCP Registry):

```json
{
  "itemType": "mcpServer", "source": "mcp-registry", "rank": 1,
  "id": "com.supabase/mcp", "name": "Supabase", "description": "MCP server for interacting with the Supabase platform",
  "version": "0.14.0", "url": "https://supabase.com/mcp", "repositoryUrl": "https://github.com/supabase/mcp",
  "remotes": [{ "type": "streamable-http", "url": "https://mcp.supabase.com/mcp" }],
  "packages": [{ "registryType": "npm", "identifier": "@supabase/mcp-server-supabase", "version": "0.14.0", "transport": "stdio" }],
  "npmWeeklyDownloads": 68012, "status": "active", "publishedAt": "2026-10-14T15:34:03.096613Z"
}
```

`securityVerdict` combines the audits: `pass` (all pass), `warn` (at least one warning), `fail` (at least one fail or high risk) or `unaudited`.

### How much does it cost?

Pay per event: **$0.005 per run + $0.0015 per result** ($1.50 per 1,000), with details included. No compute charges.

| You get | You pay (Starter/Bronze plan) |
|---|---|
| 30 results (10 per source) | $0.05 |
| 150 results (default, 50 per source) | $0.23 |
| 1,000 results | $1.51 |

Apify's **free plan includes $5 of usage every month**, and free-plan users pay **half price**. Paid plans get volume discounts (Silver -10%, Gold and above -20%).

### Use cases

- **Developers and AI engineers**: choose a skill or MCP server for Claude Code, Cursor or Codex with numbers, not hype.
- **Platform and security teams**: keep an approved list and flag skills with failing audits.
- **Dev-tool companies and DevRel**: track your skill's and MCP server's installs against competitors, every week.
- **Newsletter writers and directory builders**: "top new MCP servers this week" and "fastest-growing agent skills" in one scheduled run.
- **AI agents**: call it through the Apify MCP server to answer "which MCP server should I use for X?".

### Run it from code (API, Python, JavaScript)

```bash
curl -X POST "https://api.apify.com/v2/acts/api-co~agent-skills-mcp-directory/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" -d '{"searchTerms": ["browser"], "maxItemsPerSource": 10}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("api-co/agent-skills-mcp-directory").call(run_input={"sources": ["skills-sh"], "skillsView": "trending"})
for s in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(s["rank"], s["id"], s.get("installsRecent"), s.get("securityVerdict"))
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('api-co/agent-skills-mcp-directory').call({ searchTerms: ['postgres'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### FAQ

**What is an agent skill?**
A folder with a `SKILL.md` file (plus optional scripts) that teaches an AI coding agent how to do a task. Claude Code, Codex, Cursor, Copilot, Gemini CLI and others can load them. skills.sh tracks installs made with `npx skills add`.

**How does search work?**
On skills.sh, terms are matched against the name, repository and (with details on) the description, summary and topics of skills on the selected leaderboard (top 600). Smithery and the MCP Registry are searched with their own search APIs.

**What do the leaderboards mean?**
*All-time* ranks by total installs. *Trending* ranks by recent growth and reports `installsRecent`. *Hot* compares the last hour with the same hour yesterday (`installsLastHour`, `installsSameHourYesterday`, `hourlyChange`).

**Why don't MCP Registry servers have a usage number?**
The official registry does not publish usage. For npm packages the Actor adds `npmWeeklyDownloads`, and with a GitHub token it adds stars, last push date, license and archived status.

**Are the security audits mine to rely on?**
They come from skills.sh's audit partners and are a useful first filter. Always read a skill's SKILL.md and source before installing it on a machine that matters.

**Is this allowed?**
The Actor reads public pages that robots.txt allows (it does not use skills.sh's /api/ paths) and the public Smithery and MCP Registry APIs, with polite rate limits. Skill content belongs to its authors under their repositories' licenses.

### Related Actors

- [AI Bot Analytics & AI Crawler Checker](https://apify.com/api-co/ai-bot-analytics): see which AI agents visit your site.
- [AI Model Leaderboard](https://apify.com/api-co/ai-model-leaderboard): LMArena rankings, prices and new model releases.
- [Hacker News Scraper](https://apify.com/api-co/hacker-news-scraper): what developers are discussing.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords such as 'postgres', 'react', 'browser', 'stripe' or 'seo'. Leave empty to get the top-ranked skills and servers. One word per term works best.

## `sources` (type: `array`):

Default: all three.

## `skillsView` (type: `string`):

Which skills.sh ranking to read (each holds the top 600 skills).

## `includeSkillDetails` (type: `boolean`):

Opens each skill's page for its description, summary, topics, GitHub stars, first-seen date, 8-week install trend and security audit verdicts (Gen Agent Trust Hub, Socket, Snyk). Also lets search terms match descriptions.

## `includeMcpTools` (type: `boolean`):

Adds the tool list (names and descriptions), prompt and resource counts and connection type of each Smithery server.

## `registryNewWithinDays` (type: `integer`):

With no search terms, the official MCP Registry returns the newest servers published or updated in this window, newest first. With search terms, it is searched instead.

## `maxItemsPerSource` (type: `integer`):

Top N from each source.

## `maxItems` (type: `integer`):

Stop after this many results. You are only charged per result.

## `githubToken` (type: `string`):

A GitHub personal access token (no scopes needed). Adds GitHub stars, last push date, license and archived status to MCP Registry servers.

## `smitheryApiKey` (type: `string`):

Your own Smithery API key, if you have one. Not needed for normal use.

## Actor input object example

```json
{
  "searchTerms": [],
  "sources": [
    "skills-sh",
    "smithery",
    "mcp-registry"
  ],
  "skillsView": "all-time",
  "includeSkillDetails": true,
  "includeMcpTools": true,
  "registryNewWithinDays": 14,
  "maxItemsPerSource": 10,
  "maxItems": 150
}
```

# Actor output Schema

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

Agent skills and MCP servers.

# 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 = {
    "searchTerms": [],
    "maxItemsPerSource": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-co/agent-skills-mcp-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 = {
    "searchTerms": [],
    "maxItemsPerSource": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("api-co/agent-skills-mcp-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 '{
  "searchTerms": [],
  "maxItemsPerSource": 10
}' |
apify call api-co/agent-skills-mcp-directory --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,api-co/agent-skills-mcp-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/Sd2KhU5330fPlxeAg/builds/fs1OjFw7GvKk1W9If/openapi.json