Pricing

Pay per usage

skill-to-mcp - Model Context Protocol Server Generator

Turn plain-English tool descriptions into complete Model Context Protocol MCP servers. AI infers JSON Schema, generates Pydantic v2 models, handler code, stdio/SSE transport. Works with Claude Desktop, Cursor, MCP hosts. 3 free runs!

Pricing

Pay per usage

Rating

0.0

(0)

Developer

opportunity-biz

Actor stats

Bookmarked

Total users

Monthly active users

14 hours ago

Last modified

Categories

MCP servers

Developer tools

You can access the skill-to-mcp - Model Context Protocol Server Generator programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in Integrations settings in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "2.2",
    "x-build-id": "BtOwW9QXOPp7C90Jh"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/opportunity-biz~skill-to-mcp/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-opportunity-biz-skill-to-mcp",
        "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/opportunity-biz~skill-to-mcp/runs": {
      "post": {
        "operationId": "runs-sync-opportunity-biz-skill-to-mcp",
        "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/opportunity-biz~skill-to-mcp/run-sync": {
      "post": {
        "operationId": "run-sync-opportunity-biz-skill-to-mcp",
        "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": [
          "skillText"
        ],
        "properties": {
          "skillText": {
            "title": "📝 Skill Description",
            "type": "string",
            "description": "Describe your tool in plain English. What does it do? What inputs does it need? What outputs should it return? Be as specific as possible for the best results."
          },
          "model": {
            "title": "🤖 LLM Model",
            "enum": [
              "deepseek-v4-flash",
              "deepseek-chat",
              "gpt-4o-mini"
            ],
            "type": "string",
            "description": "The AI model used to infer your tool schema. DeepSeek works great and costs less than $0.001 per generation. You bring your own API key.",
            "default": "deepseek-v4-flash"
          },
          "transport": {
            "title": "🔌 MCP Transport",
            "enum": [
              "stdio",
              "sse"
            ],
            "type": "string",
            "description": "How will your MCP server communicate? stdio works with Claude Desktop & Cursor IDE. SSE is for HTTP-based hosts.",
            "default": "stdio"
          },
          "withExampleImpl": {
            "title": "✨ Generate Working Example Code",
            "type": "boolean",
            "description": "Generate a complete, working handler implementation instead of a TODO stub. The AI will write the actual business logic for you. Great for getting started fast!",
            "default": false
          },
          "apiKey": {
            "title": "🔑 Your DeepSeek or OpenAI API Key",
            "type": "string",
            "description": "Your own API key (DeepSeek: platform.deepseek.com, OpenAI: platform.openai.com). Your key is never stored — each run uses it to call the LLM. Cost per generation: less than $0.001."
          }
        }
      },
      "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
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

skill-to-mcp — MCP Server Generator OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for skill-to-mcp - Model Context Protocol Server Generator from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

skill-to-mcp - Model Context Protocol Server Generator API in Python

skill-to-mcp - Model Context Protocol Server Generator API in JavaScript

skill-to-mcp - Model Context Protocol Server Generator API through CLI

skill-to-mcp - Model Context Protocol Server Generator API

Google Search MCP Server

viralanalyzer/mcp-google-search

Expose Google Search to your AI Agents (Claude Desktop, Cursor) as a standardized Model Context Protocol (MCP) Server via SSE HTTP, with Pay-Per-Event billing.

viralanalyzer

GitHub MCP Server 🐙 - AI Agent Connector

10emmmm/github-mcp-server

Connect AI Agents (Claude, Cursor) to your private GitHub repos via MCP (Model Context Protocol). Secure, pay-per-event, and runs via SSE.

AJ4N3NZ0

Time MCP Server

agentify/time-mcp-server

An MCP server implementing the Model Context Protocol (MCP) for time-related operations.

agentify

MCP tools – Turn Any Website into an AI Tool in 60 Seconds

clever_fashion/mcp-website-tool

Automatically extract buttons, inputs & forms from any site and get ready-to-use MCP (Model Context Protocol) tools for Cursor, Claude, Claude Desktop, Windsurf, Cline, and any MCP-compatible AI.

Data Farming Team

MCP Config Generator (Apify Actor → Claude / Cursor)

gochujang/mcp-config-generator

Given any Apify actor ID, generates ready-to-paste Model Context Protocol (MCP) server configs for Claude Desktop, Claude Code, and Cursor. Wraps the actor as a tool Claude can call directly. $0.005 per config.

Hojun Lee

MCP Web Scraper Server — AI-Ready Web Scraping via MCP

junipr/mcp-web-scraper

Model Context Protocol (MCP) server for web scraping. Provides scrape, extract, search, and link discovery tools via SSE or WebSocket transport. Connect AI agents and LLMs to live web data.

junipr

Web Search MCP

silicatelabs/Web-Search-MCP

An Apify Actor that runs a persistent **Model Context Protocol (MCP) server**, giving AI assistants real-time web search capabilities. Connect Claude Desktop, Cursor, or any MCP-compatible AI client to search the web without leaving your workflow.

Silicate Labs

Playwright MCP Server — Browser Automation via MCP Protocol

junipr/playwright-mcp-server

Model Context Protocol (MCP) server providing Playwright browser automation tools. Navigate, click, fill forms, take screenshots, evaluate JS — all via WebSocket MCP transport for AI agents.

junipr

AgentPilot — API AI-Readiness & MCP Server Generator

orbitai/agent-pilot-mcp-generator

Audits public OpenAPI specifications for AI suitability and automatically generates run-ready typescript/python Model Context Protocol (MCP) server code packages.