The OpenAPI MCP Proxy enables operations teams to explore large OpenAPI schemas without loading entire schemas into LLM context. It connects to Claude agents and supports Python workflows.
git clone https://github.com/nyudenkov/openapi-mcp-proxy.gitThe openapi-mcp-proxy skill is an automation tool designed for exploring large OpenAPI schemas efficiently. By acting as an MCP server, it provides developers and product managers with the necessary tools to navigate complex API documentation with ease. This skill streamlines the process of understanding and interacting with APIs, making it an essential asset for teams working in API-driven environments. One of the key benefits of the openapi-mcp-proxy skill is its ability to save time during the API exploration phase. While specific time savings are not quantified, the skill's intermediate implementation difficulty means that users can expect to set it up in approximately 30 minutes. This quick setup allows teams to focus more on developing applications rather than spending excessive time deciphering API documentation, ultimately enhancing productivity. This skill is particularly valuable for developers, product managers, and AI practitioners who frequently engage with APIs. By simplifying the exploration of OpenAPI schemas, it enables these professionals to quickly understand the capabilities of various APIs and integrate them into their projects. For example, a developer can use this skill to quickly assess the endpoints and data structures of a new API, facilitating faster integration into their applications. With an intermediate complexity level, the openapi-mcp-proxy skill is suitable for those with some experience in API management and automation. It fits seamlessly into AI-first workflows by providing a structured approach to API exploration, which is crucial for leveraging AI automation and enhancing workflow automation. This skill not only improves the efficiency of API interactions but also empowers teams to innovate and deliver solutions more rapidly.
1. **Install the OpenAPI MCP Proxy**: Ensure the proxy is installed in your Claude/ChatGPT environment. You can find it in the [MCP Proxy GitHub repository](https://github.com/modelcontextprotocol/mcp-proxy). 2. **Configure the Proxy**: Set up the proxy to connect to your target OpenAPI schema. For example, if exploring the Salesforce API, configure the proxy with the schema URL: `https://developer.salesforce.com/docs/api/explore`. 3. **Define Your Focus Area**: Use the prompt template to specify the endpoint path (e.g., `/services/data/v58.0/sobjects/Lead`), operation method (e.g., GET, POST), and specific details to extract (e.g., parameters, examples). 4. **Execute the Query**: Paste the prompt into your AI assistant (e.g., Claude or ChatGPT) and run it. The proxy will fetch the relevant portion of the schema and return a structured summary. 5. **Refine and Iterate**: If the results are too broad, refine your prompt by narrowing the focus (e.g., specify a particular field or constraint). Use the proxy to explore additional endpoints or methods as needed. **Tips for Better Results:** - **Be Specific**: Clearly define the endpoint path, operation method, and details to extract. Vague prompts may return overly broad or irrelevant results. - **Use Examples**: Include example request/response pairs in your prompt to guide the AI in formatting the output. - **Validate Constraints**: Pay attention to rate limits, field requirements, and other constraints mentioned in the schema. These are critical for successful API integration. - **Iterate**: If the initial results are incomplete, iterate by refining your prompt or exploring additional endpoints.
No install command available. Check the GitHub repository for manual installation instructions.
git clone https://github.com/nyudenkov/openapi-mcp-proxyCopy the install command above and run it in your terminal.
Launch Claude Code, Cursor, or your preferred AI coding agent.
Use the prompt template or examples below to test the skill.
Adapt the skill to your specific use case and workflow.
Use the OpenAPI MCP Proxy to explore the [OPENAPI_SPEC_URL] schema for [ENDPOINT_PATH]. Focus on [OPERATION_METHOD] operations and extract [SPECIFIC_DETAILS] such as request/response schemas, parameters, and examples. Return a structured summary that includes: 1) A list of relevant endpoints with their descriptions, 2) Key parameters and their data types, 3) Example request/response pairs, and 4) Any constraints or limitations mentioned in the schema.
### OpenAPI Schema Exploration Report: Salesforce API (v58.0)
**Explored Schema:** `https://developer.salesforce.com/docs/api/explore`
**Focus Area:** Lead and Opportunity Management
**Operation Method:** GET, POST, PATCH
---
#### 1. Relevant Endpoints Identified:
| Endpoint | Method | Description |
|----------|--------|-------------|
| `/services/data/v58.0/sobjects/Lead` | GET | Retrieve a list of leads with optional filtering. |
| `/services/data/v58.0/sobjects/Lead/{id}` | GET | Retrieve a specific lead by ID. |
| `/services/data/v58.0/sobjects/Lead` | POST | Create a new lead record. |
| `/services/data/v58.0/sobjects/Lead/{id}` | PATCH | Update an existing lead record. |
---
#### 2. Key Parameters and Data Types:
**Query Parameters for `GET /sobjects/Lead`:**
- `q` (string): SOQL query string (e.g., `q=LastName LIKE 'Smith'`).
- `fields` (string): Comma-separated list of fields to return (e.g., `fields=Id,Name,Email,Company`).
- `limit` (integer): Maximum number of records to return (default: 200, max: 2000).
**Request Body for `POST /sobjects/Lead`:**
```json
{
"FirstName": "Jane",
"LastName": "Doe",
"Company": "TechCorp",
"Email": "[email protected]",
"Phone": "+1 (555) 123-4567",
"Status__c": "New",
"LeadSource": "Web"
}
```
**Response Fields for `GET /sobjects/Lead/{id}`:**
- `Id` (string): Unique identifier for the lead (e.g., `00Q5g000006J5hOEAS`).
- `Name` (string): Full name of the lead (e.g., `Jane Doe`).
- `Company` (string): Company name (e.g., `TechCorp`).
- `Email` (string): Email address (e.g., `[email protected]`).
- `Status__c` (string): Custom field for lead status (e.g., `New`, `Contacted`, `Qualified`).
---
#### 3. Example Request/Response Pairs:
**Example 1: Retrieve Leads with SOQL Query**
**Request:**
```
GET /services/data/v58.0/query?q=SELECT+Id,Name,Email,Company+FROM+Lead+WHERE+Status__c='New'+LIMIT+10
```
**Response:**
```json
{
"totalSize": 3,
"done": true,
"records": [
{
"Id": "00Q5g000006J5hOEAS",
"Name": "Jane Doe",
"Email": "[email protected]",
"Company": "TechCorp"
},
{
"Id": "00Q5g000006J5hOEAQ",
"Name": "John Smith",
"Email": "[email protected]",
"Company": "Innovate Inc."
},
{
"Id": "00Q5g000006J5hOFAA",
"Name": "Sarah Johnson",
"Email": "[email protected]",
"Company": "Global Solutions"
}
]
}
```
**Example 2: Create a New Lead**
**Request:**
```
POST /services/data/v58.0/sobjects/Lead
Headers: {"Authorization": "Bearer [ACCESS_TOKEN]"}
Body:
{
"FirstName": "Michael",
"LastName": "Brown",
"Company": "DataSystems",
"Email": "[email protected]",
"Phone": "+1 (555) 987-6543",
"Status__c": "New",
"LeadSource": "Web"
}
```
**Response:**
```json
{
"id": "00Q5g000006J5hOGAS",
"success": true,
"errors": []
}
```
---
#### 4. Constraints and Limitations:
- **Rate Limits:** Salesforce enforces a limit of **100 requests per 20 seconds** for standard API calls. Exceeding this limit results in a `429 Too Many Requests` error.
- **Field Length:** The `Company` field has a maximum length of **255 characters**. Attempting to create a lead with a longer company name will result in a validation error.
- **Required Fields:** The `LastName` field is required for lead creation. Omitting it will trigger an error.
- **Custom Fields:** Custom fields (e.g., `Status__c`) must be explicitly enabled in the Salesforce schema. If not enabled, the API will return a `400 Bad Request` error.
---
#### Summary:
This exploration of the Salesforce API schema reveals a robust set of endpoints for lead and opportunity management. The schema supports CRUD operations with clear parameter requirements and response structures. Key takeaways include the need to handle rate limits, validate custom field availability, and ensure required fields are populated during lead creation. This summary can be used to guide API integration efforts or troubleshoot existing workflows.24/7 AI-powered support ticket resolution
Get more done every day with Microsoft Teams – powered by AI
Automate security compliance and monitor real-time security posture seamlessly.
Automate your spreadsheet tasks with AI power
Agentic AI Workflow platform
Connected workspace for docs, wikis, and projects
Take a free 3-minute scan and get personalized AI skill recommendations.
Take free scan