Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-ctftime show me the top 10 CTF teams for this year"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP (Model Context Protocol) server that wraps the public CTFtime API, enabling AI assistants to query CTF events, teams, rankings, and results.
npx mcp-ctftimenpm install -g mcp-ctftime
mcp-ctftimegit clone https://github.com/tomek7667/mcp-ctftime.git
cd mcp-ctftime
pnpm install
pnpm build
pnpm startRelated MCP server: CTFd MCP Server
Tool | Description |
| List events in a UNIX timestamp window |
| Get event details by ID |
| Get top teams (current or specific year) |
| Get top teams by country (current year) |
| Get team details by ID |
| Get event results for a year |
| Get event votes for a year |
Claude Desktop supports MCP servers via a JSON configuration file.
Config file location:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Using npx (recommended):
{
"mcpServers": {
"ctftime": {
"command": "npx",
"args": ["-y", "mcp-ctftime"]
}
}
}Using global install:
{
"mcpServers": {
"ctftime": {
"command": "mcp-ctftime"
}
}
}Restart Claude Desktop after editing the config.
Codex CLI stores MCP configuration in ~/.codex/config.toml.
Using the CLI:
codex mcp add ctftime -- npx -y mcp-ctftimeOr edit ~/.codex/config.toml directly:
[mcp_servers.ctftime]
command = "npx"
args = ["-y", "mcp-ctftime"]Using global install:
[mcp_servers.ctftime]
command = "mcp-ctftime"Use /mcp in the Codex TUI to verify the server is connected.
Amp supports MCP servers via the amp.mcpServers setting in VS Code settings.json or via CLI.
Config file location (VS Code):
macOS: ~/Library/Application Support/Code/User/settings.json
Windows: %APPDATA%\Code\User\settings.json
Linux: ~/.config/Code/User/settings.json
Using npx (recommended):
{
"amp.mcpServers": {
"ctftime": {
"command": "npx",
"args": ["-y", "mcp-ctftime"]
}
}
}Using global install:
{
"amp.mcpServers": {
"ctftime": {
"command": "mcp-ctftime"
}
}
}Via CLI:
amp mcp add ctftime npx -y mcp-ctftimeGemini CLI stores MCP configuration in ~/.gemini/settings.json.
Using npx (recommended):
{
"mcpServers": {
"ctftime": {
"command": "npx",
"args": ["-y", "mcp-ctftime"]
}
}
}Using global install:
{
"mcpServers": {
"ctftime": {
"command": "mcp-ctftime"
}
}
}Via CLI:
gemini mcp add ctftime npx -- -y mcp-ctftimeUse /mcp in Gemini CLI to verify server status.
docker build -t mcp-ctftime .
docker run -i mcp-ctftimeFor clients that support Docker-based MCP servers:
{
"mcpServers": {
"ctftime": {
"command": "docker",
"args": ["run", "-i", "--rm", "mcp-ctftime"]
}
}
}Feature | Supported |
Transport | stdio |
Node.js | >=18.0.0 |
Platforms | macOS, Linux, Windows |
Client | Status |
Claude Desktop | ✅ Verified |
OpenAI Codex CLI | ✅ Verified |
Amp | ✅ Verified |
Gemini CLI | ✅ Verified |
Currently, this server does not require any environment variables. The CTFtime API is public and does not require authentication.
# Clone and install
git clone https://github.com/tomek7667/mcp-ctftime.git
cd mcp-ctftime
pnpm install
# Build
pnpm build
# Run
pnpm start
# Watch mode (auto-rebuild)
pnpm watchThis server wraps the public CTFtime API: https://ctftime.org/api/
All timestamps use UNIX epoch seconds. Country codes use ISO 3166-1 alpha-2 format (lowercase, e.g., us, de, pl).
Get full details for a specific CTFtime event by event_id.
| Name | Required | Description | Default |
|---|---|---|---|
| event_id | Yes | CTFtime event id. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It merely states 'Get full details' without explaining what 'full details' includes, potential errors, rate limits, or authentication requirements. This lack of detail is insufficient.
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 a single, concise sentence with no extraneous information. It is front-loaded with the purpose and required parameter, making it easy to parse.
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 absence of an output schema and annotations, the description is minimally adequate but lacks details on the return format, error handling, or examples. For a simple retrieval tool it may suffice, but it could be more informative.
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?
The schema already describes the event_id parameter adequately ('CTFtime event id.'). The description adds no new semantic information about the parameter beyond what the schema provides, so a baseline score of 3 is appropriate.
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 clearly specifies the action 'Get full details' and the resource 'specific CTFtime event' with the required identifier 'by event_id.' It effectively distinguishes this tool from siblings like ctftime_events (which likely lists events) and others.
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 when an event_id is known and full details are needed, but it does not provide explicit guidance on when to use this tool over alternatives, nor does it mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List CTFtime events in a time window. Uses UNIX timestamps (seconds) for start/finish; returns past and upcoming events.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max events (1-100). | |
| start | No | UNIX timestamp (seconds) for window start. | |
| finish | No | UNIX timestamp (seconds) for window finish. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the use of UNIX timestamps and that both past and upcoming events are returned. However, it does not mention ordering, pagination, or any potential limits beyond the parameter schema. This leaves gaps in understanding the tool's behavior.
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 extremely concise: two sentences that clearly state the purpose, input format, and output scope. No unnecessary words or 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 simple parameter set (3 optional integers) and no output schema, the description combined with the schema covers most needs. It could be improved by noting ordering or pagination behavior, but overall it is sufficient for an agent to select and invoke the tool 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 the baseline is 3. The description adds that the tool returns past and upcoming events, which is not in the schema. However, the timestamp format is already described in the schema, so the added value is marginal.
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 clearly states the tool lists CTFtime events within a specified time window using UNIX timestamps. The verb 'list' and resource 'CTFtime events' are specific, and it distinguishes from siblings like ctftime_event (singular) and others that handle results or teams.
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 for listing events in a time window but does not explicitly state when to use or avoid this tool compared to alternatives like ctftime_event for single events. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get event results for a year (or current year if omitted).
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Year (e.g., 2025). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits such as result format, pagination, ordering, or any side effects. The description is too brief to cover necessary behavioral context.
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 a single sentence, efficient and front-loaded. It earns its place but could benefit from slight expansion on output to improve completeness.
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 no output schema, the description fails to explain what 'event results' actually contain—whether it's scores, rankings, or event details. This lack of completeness hinders proper tool selection and 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?
The schema describes the year parameter with type and bounds, and the description adds that omitting it uses the current year. This adds practical meaning beyond the schema, which had no default hint.
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 clearly states the tool gets event results for a year, with the default being the current year. This distinguishes it from siblings like ctftime_event (single event) and ctftime_events (list events).
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 for retrieving results by year or defaulting to current, but does not provide explicit guidance on when to use this tool versus alternatives like ctftime_top_teams or ctftime_votes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get information about a specific team by team_id.
| Name | Required | Description | Default |
|---|---|---|---|
| team_id | Yes | CTFtime team id. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description implies a read operation but lacks details on data freshness, rate limits, or response structure. Adequate but not rich.
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?
Single concise sentence front-loading the purpose with no extraneous information.
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?
Simple tool with one parameter and no output schema; description covers the essential purpose. Minor gaps like authentication or error handling, but adequate for the complexity.
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% with 'CTFtime team id.' for team_id. Description adds no additional meaning beyond the schema, so baseline 3.
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?
Description clearly states 'Get information about a specific team by team_id.' with a specific verb and resource, distinguishing it from siblings like ctftime_events or ctftime_top_teams.
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?
No guidance on when to use this tool versus alternatives like ctftime_top_by_country or ctftime_events. The description only states what it does.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get top teams for the current year by country (ISO 3166-1 alpha-2 country code, lowercase).
| Name | Required | Description | Default |
|---|---|---|---|
| country_code | Yes | Country code (e.g., 'pl', 'us', 'de'). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses that results are for the current year but omits behavioral traits like authentication, rate limits, or error handling. Adequate but minimal.
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?
Single sentence with no extraneous words. Every part is necessary and informative.
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?
For a simple one-parameter tool with no output schema, the description covers the core purpose and parameter format. It does not mention return structure, but given the straightforward nature, it is reasonably complete.
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?
The schema already describes country_code with min/max length, but the description adds critical format details ('ISO 3166-1 alpha-2, lowercase'), providing value beyond the schema.
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 clearly states the action (Get top teams), resource (by country), and specific constraints (current year, ISO 3166-1 alpha-2 lowercase). It distinguishes from siblings like ctftime_top_teams by adding the country filter.
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 for retrieving top teams of a specific country but offers no guidance on when to use this tool versus alternatives like ctftime_top_teams or ctftime_team. No explicit when/not-to-use context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get top teams for a year (or current year if year omitted).
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Year (e.g., 2025). | |
| limit | No | Max teams (1-100). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry burden. It correctly implies a read operation ('get') and mentions the default year behavior. However, it does not disclose ordering criteria, data freshness, or any rate limits, leaving gaps.
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?
Single sentence with verb and object upfront, no redundant words. Every part serves a purpose.
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 no output schema and siblings, the description lacks crucial details: how top teams are ranked (e.g., points?), what output fields are returned, and that limit defaults to 10 (mentioned only in schema). It is too minimal for full context.
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%, with clear parameter descriptions. Description adds value by clarifying that year defaults to current year when omitted, which is not in schema. This enhances agent understanding.
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?
Description clearly states the action 'Get top teams' and the condition 'for a year (or current year if omitted)'. It is specific and distinguishes from siblings like 'ctftime_top_by_country' by omission, but does not explicitly differentiate.
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?
Description only states when to use (for a year) but provides no guidance on when not to use, prerequisites, or alternatives like 'ctftime_top_by_country' or 'ctftime_results'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get event votes for a year.
| Name | Required | Description | Default |
|---|---|---|---|
| year | Yes | Year (e.g., 2025). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description does not disclose any behavioral traits such as read-only nature, rate limits, or required permissions. The tool's behavior is assumed from its name only.
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?
A single, direct sentence with no extraneous words. Highly concise.
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?
For a simple tool with one parameter and no output schema, the description is adequate but lacks details on the return format or limitations, which would help an agent fully understand the tool's output.
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?
The description adds no meaning beyond the input schema, which already describes the year parameter with an example. Since schema coverage is 100%, baseline is 3.
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 clearly states the tool retrieves event votes for a year, distinguishing it from siblings that deal with events, results, or teams. However, it does not define 'event votes,' but the purpose is unambiguous.
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?
No guidance on when to use this tool versus alternatives like ctftime_events or ctftime_results. The description provides no context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0ctftime_eventctftime_eventsctftime_resultsctftime_teamctftime_top_by_countryctftime_top_teamsctftime_votesEach tool targets a distinct CTFtime resource: event details, event listing, results, team info, top teams (overall and by country), and votes. No overlapping functionality.
All tools follow the 'ctftime_' prefix with underscore-separated lowercase names. While verbs are not uniform (e.g., 'event' vs 'events', 'top_by_country'), the pattern is predictable and consistent.
Seven tools cover the core read operations for CTFtime without being excessive. The number feels well-scoped for a focused data retrieval server.
The tool set covers essential queries: single event, list events, results, team info, top teams, and votes. Minor gaps like search or filtering by year in some tools are not critical.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Real-time CVE, exploit, and vulnerability intelligence for AI assistants (350K+ CVEs, 115K+ PoCs)
Query your team's drift, vulnerability, and upgrade data from any AI assistant. OAuth 2.1, 51 tools.
CVE lookups (NVD) and dependency-manifest audits (OSV) for AI agents. No API keys.
Independent directory of agentic AI tools — search, compare & recommend via MCP. Read-only.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/tomek7667/mcp-ctftime'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
