# Glama MCP Registry Scraper (`maximedupre/glama-mcp-registry-scraper`) Actor

Scrape Glama MCP registry servers from catalog, search, or server IDs. Export source-backed MCP server metadata, environment schema, repository facts, and readiness fields.

- **URL**: https://apify.com/maximedupre/glama-mcp-registry-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.01 / 1,000 scraped servers

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### 🔎 Glama MCP registry scraper for server data

Glama MCP Registry Scraper collects public server listings from the [Glama MCP registry](https://glama.ai/mcp/servers). Use this glama mcp registry scraper to export Model Context Protocol server metadata from the catalog, a search query, or exact Glama server IDs without opening each listing by hand.

Each saved row is one Glama MCP server. Rows include the server ID, name, namespace, slug, description, Glama attributes, source repository URL, license, environment schema, required and optional environment variables, hosting readiness, repository language, star count, homepage, source update timestamp, and source-backed tool records when Glama exposes them.

You do not need a Glama account, API key, cookies, or private workspace access. For a quick first run, keep the prefilled `github` search query and `Maximum servers` set to `144`. The run saves clean dataset rows you can export from Apify, query through the API, schedule, or send to another tool through an integration.

### ✅ What this Actor does

- Scrapes the Glama MCP catalog and saves one row per MCP server.
- Searches server names, descriptions, namespaces, and attributes with one or more search queries.
- Looks up exact Glama server IDs for detail runs.
- Filters catalog or search output by Glama attributes such as `hosting:remote-capable` or `author:official`.
- Filters by repository language when the public source repository exposes it.
- Extracts environment schema facts into `requiredVariables`, `optionalVariables`, and the original source schema.
- Adds mechanical readiness fields from source-backed data, such as hosting type, environment requirements, and repository metadata.
- Charges only successfully saved server rows.

### 📦 Data you can export

The dataset is built for developers, AI tooling teams, registry builders, and product researchers who need MCP server data in a repeatable format.

Typical fields include:

- `serverId`, `name`, `namespace`, and `slug`
- `description` and source-native `attributes`
- `readiness.hosting`, `readiness.score`, and `readiness.reasons`
- `environment.requiredVariables`, `environment.optionalVariables`, and `environment.schema`
- `sourceRepositoryUrl`, `homepageUrl`, `license`, `language`, `starCount`, and `sourceUpdatedAt`
- `tools`, `resources`, and `prompts` arrays when source-backed records are exposed

Glama server page URLs are not duplicated in the dataset because they can be rebuilt from `serverId` as `https://glama.ai/mcp/servers/{serverId}`.

### 🚀 How to run it

Fill one target section per run:

1. Use **Search queries** for the easiest first run. Example: `github`, `slack`, or `database`.
2. Use **Collect catalog** to export the current Glama MCP catalog.
3. Use **Server IDs** when you already know exact Glama IDs, such as `hl7cazcjt9`.

Then set `Maximum servers`. Attribute filters and language filters apply to catalog and search runs. If you fill more than one target section, the Actor stops safely and asks you to clear the extra target sections.

### 🧾 Input reference

- `collectCatalog`: Collect matching servers from the Glama catalog.
- `searchQueries`: Search Glama MCP servers by names, descriptions, namespaces, and attributes.
- `serverIds`: Look up exact Glama server IDs.
- `attributeFilters`: Keep only rows with matching source attributes.
- `languageFilters`: Keep only rows with matching repository language.
- `maxItems`: Limit how many matching servers are saved.

### 🧪 Output example

```json
{
  "serverId": "hl7cazcjt9",
  "name": "proofdrop-mcp",
  "namespace": "mezotv",
  "slug": "proofdrop",
  "description": "Enables AI agents to upload temporary public review artifacts...",
  "attributes": ["hosting:remote-capable"],
  "readiness": {
    "hosting": "remote-capable",
    "score": 90,
    "reasons": [
      "Remote-Capable hosting",
      "Environment schema exposes required variables",
      "Repository language is available",
      "Repository update timestamp is available"
    ]
  },
  "tools": [],
  "resources": [],
  "prompts": [],
  "installCommand": null,
  "environment": {
    "requiredVariables": ["AWS_REGION", "AWS_ACCESS_KEY_ID"],
    "optionalVariables": ["MCP_PORT"],
    "schema": {
      "type": "object",
      "required": ["AWS_REGION", "AWS_ACCESS_KEY_ID"]
    }
  },
  "sourceRepositoryUrl": "https://github.com/mezotv/proofdrop",
  "homepageUrl": null,
  "license": "MIT License",
  "language": "TypeScript",
  "starCount": 12,
  "sourceUpdatedAt": "2026-06-18T09:32:21Z"
}
````

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each successfully scraped Glama MCP server saved to the dataset.

You are not charged for empty searches, unknown server IDs, duplicate rows skipped inside a run, startup, or failed lookups that do not save a server row.

### ⚠️ Limits and notes

- This Actor is Glama-only. It does not aggregate Smithery, MCP.so, PulseMCP, or other MCP directories.
- It returns public registry and public repository facts. It does not test private MCP servers, call MCP tools, or validate user credentials.
- Repository language, stars, homepage, and update timestamps are included when the public source repository exposes them.
- Readiness fields are mechanical and source-backed. They are not AI recommendations.
- `tools`, `resources`, and `prompts` stay empty when Glama does not expose source-backed records for a server.

### ❓ FAQ

#### Can I scrape the whole Glama MCP registry?

Yes. Use **Collect catalog** and raise `Maximum servers` to the number of rows you want. For a first run, start smaller so you can inspect the output shape.

#### Can I search for MCP servers by topic?

Yes. Use **Search queries** with phrases such as `github`, `database`, `browser`, or `slack`. The Actor saves matching Glama MCP server rows.

#### Does this require a Glama API key?

No. The Actor uses public Glama MCP registry data and public repository metadata. You do not need to provide a Glama account, API key, cookies, or GitHub token.

#### Does it run as an MCP server?

No. This is an Apify Actor that exports Glama MCP registry data to a dataset. It does not expose live MCP tools or call MCP servers.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~glama-mcp-registry-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [ChatGPT Marketplace Scraper ↗](https://apify.com/maximedupre/chatgpt-marketplace-scraper) - Export public custom GPT listings, creators, categories, capabilities, and usage facts.
- [Chrome Extensions Scraper ↗](https://apify.com/maximedupre/chrome-extensions-scraper) - Collect Chrome Web Store extension metadata, manifests, permissions, media, and publisher facts.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Crawl public websites and export rendered links, sitemap URLs, depth, and status data.
- [Schema Markup Validator ↗](https://apify.com/maximedupre/schema-markup-validator) - Audit public pages for JSON-LD, Microdata, RDFa, meta tags, and rich-result readiness.
- [Sitemap Sniffer ↗](https://apify.com/maximedupre/sitemap-sniffer) - Find public sitemap files, sitemap indexes, URL counts, and sitemap metadata.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `collectCatalog` (type: `boolean`):

Collect matching servers from the Glama MCP catalog.

## `searchQueries` (type: `array`):

Search server names, descriptions, namespaces, and attributes.

## `serverIds` (type: `array`):

Add Glama server IDs for detail runs.

## `attributeFilters` (type: `array`):

Filter catalog or search results by Glama attributes.

## `languageFilters` (type: `array`):

Filter catalog or search results by primary language.

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

Limit how many matching servers are saved for catalog or search runs.

## Actor input object example

```json
{
  "collectCatalog": false,
  "searchQueries": [
    "github"
  ],
  "maxItems": 144
}
```

# Actor output Schema

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

Open the dataset with one saved row for each scraped Glama MCP server.

# 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 = {
    "collectCatalog": false,
    "searchQueries": [
        "github"
    ],
    "maxItems": 144
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/glama-mcp-registry-scraper").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 = {
    "collectCatalog": False,
    "searchQueries": ["github"],
    "maxItems": 144,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/glama-mcp-registry-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "collectCatalog": false,
  "searchQueries": [
    "github"
  ],
  "maxItems": 144
}' |
apify call maximedupre/glama-mcp-registry-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/glama-mcp-registry-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Glama MCP Registry Scraper",
        "description": "Scrape Glama MCP registry servers from catalog, search, or server IDs. Export source-backed MCP server metadata, environment schema, repository facts, and readiness fields.",
        "version": "0.0",
        "x-build-id": "ZvvJTITNRcjjsCmo8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~glama-mcp-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-glama-mcp-registry-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~glama-mcp-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-glama-mcp-registry-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~glama-mcp-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-glama-mcp-registry-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "maxItems"
                ],
                "properties": {
                    "collectCatalog": {
                        "title": "Collect catalog",
                        "type": "boolean",
                        "description": "Collect matching servers from the Glama MCP catalog.",
                        "default": false
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Search server names, descriptions, namespaces, and attributes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "serverIds": {
                        "title": "Server IDs",
                        "type": "array",
                        "description": "Add Glama server IDs for detail runs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "attributeFilters": {
                        "title": "Attribute filters",
                        "type": "array",
                        "description": "Filter catalog or search results by Glama attributes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "languageFilters": {
                        "title": "Language filters",
                        "type": "array",
                        "description": "Filter catalog or search results by primary language.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum servers",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Limit how many matching servers are saved for catalog or search runs.",
                        "default": 144
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```