Api Toolkit

Comprehensive API development and testing MCP server for Claude Code

License: MIT TypeScript MCP

MCP API Toolkit brings powerful API development capabilities to Claude Code through the Model Context Protocol. Think Postman + OpenAPI + AI-powered testing, all integrated into your Claude workflow.

✨ Features

• 🔍 OpenAPI/Swagger Parsing - Import and validate API specifications
• 🧪 API Testing - Execute and validate API requests with AI insights
• 📚 Documentation Generation - Auto-generate beautiful API docs
• 🛠️ SDK Generation - Create TypeScript, Python, JavaScript SDKs automatically
• 🎭 Mock Data - Generate realistic test data from schemas
• ⚡ Batch Testing - Test multiple endpoints at once
• 🔒 Request Validation - Ensure requests/responses match schemas
• 📊 Performance Insights - Track response times and sizes

📦 Installation

NPM (Recommended)

npm install -g mcp-api-toolkit

From Source

git clone https://github.com/yourusername/mcp-api-toolkit.git
cd mcp-api-toolkit
npm install
npm run build
npm link

🔧 Configuration

Add to your Claude Code MCP settings:

macOS/Linux: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "api-toolkit": {
      "command": "mcp-api-toolkit"
    }
  }
}

Or with npx:

{
  "mcpServers": {
    "api-toolkit": {
      "command": "npx",
      "args": ["-y", "mcp-api-toolkit"]
    }
  }
}

Restart Claude Code to activate the MCP server.

🎯 Usage

1. Parse OpenAPI Specification

Parse this OpenAPI spec: https://api.example.com/openapi.json

Or paste the spec directly:

Parse this OpenAPI spec:
{
  "openapi": "3.0.0",
  "info": { "title": "My API", "version": "1.0.0" },
  ...
}

2. List API Endpoints

List all endpoints from the parsed spec

3. Test an Endpoint

Test the GET /users endpoint with authentication header

Claude will use the test_api_endpoint tool:

GET https://api.example.com/users
Headers: { "Authorization": "Bearer token" }

4. Generate SDK

Generate a TypeScript SDK from the parsed spec

Claude will create a fully-typed client library:

export class MyAPIClient {
  async getUsers(config?: RequestConfig): Promise<User[]> {
    // Auto-generated implementation
  }
}

5. Generate Documentation

Generate markdown documentation for this API

6. Create Mock Data

Generate 5 mock user objects based on this schema:
{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "email": { "type": "string" },
    "age": { "type": "number" }
  }
}

🛠️ Available Tools

parse_openapi

Parse and validate OpenAPI/Swagger specifications (JSON, YAML, or URL).

Input:

• input (string): OpenAPI spec as JSON/YAML or URL
• isUrl (boolean): Whether input is a URL

Output: Parsed specification with summary

list_endpoints

Extract all API endpoints from a specification.

Input:

• spec (string): OpenAPI spec JSON
• filterByTag (string, optional): Filter by tag
• filterByMethod (string, optional): Filter by HTTP method

Output: List of endpoints with methods and paths

test_api_endpoint

Execute and validate API requests.

Input:

• method (string): HTTP method (GET, POST, PUT, PATCH, DELETE)
• url (string): Full URL to test
• headers (object, optional): HTTP headers
• body (object, optional): Request body
• params (object, optional): Query parameters
• expectedStatus (number, optional): Expected HTTP status
• timeout (number, optional): Timeout in ms (default: 30000)

Output: Response data, status, timing, validation results

generate_sdk

Generate client SDKs in multiple languages.

Input:

• spec (string): OpenAPI spec JSON
• language (string): typescript | python | javascript | go
• clientName (string, optional): Custom client class name

Output: Generated SDK code

generate_mock_data

Create mock data from JSON schemas.

Input:

• schema (object): JSON Schema definition
• count (number, optional): Number of objects to generate

Output: Array of mock data objects

generate_api_docs

Generate markdown documentation from OpenAPI specs.

Input:

• spec (string): OpenAPI spec JSON
• includeExamples (boolean, optional): Include examples (default: true)

Output: Markdown documentation

validate_api_response

Validate responses against schemas.

Input:

• response (object): API response data
• schema (object): Expected schema

Output: Validation results

batch_test_endpoints

Test multiple endpoints at once.

Input:

• spec (string): OpenAPI spec JSON
• baseUrl (string, optional): Override base URL
• filterByTag (string, optional): Test only tagged endpoints
• headers (object, optional): Common headers

Output: Batch test results summary

📖 Examples

Example 1: Test a Public API

Parse the JSONPlaceholder API: https://jsonplaceholder.typicode.com/

Then test the GET /posts/1 endpoint

Example 2: Generate a Client Library

Parse this OpenAPI spec and generate a Python SDK:

{
  "openapi": "3.0.0",
  "info": { "title": "User API", "version": "1.0.0" },
  "servers": [{ "url": "https://api.example.com" }],
  "paths": {
    "/users": {
      "get": {
        "summary": "List users",
        "responses": {
          "200": { "description": "Success" }
        }
      }
    }
  }
}

Example 3: API Testing Workflow

1. Parse the Stripe API spec: https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json
2. List all payment-related endpoints
3. Generate TypeScript SDK
4. Create mock customer data

🎨 Use Cases

API Development

• Import existing OpenAPI specs
• Test endpoints during development
• Generate client libraries automatically
• Create API documentation

API Testing

• Validate API responses
• Batch test endpoints for health checks
• Performance testing with timing metrics
• Mock data generation for testing

API Integration

• Generate SDKs for easy integration
• Test third-party APIs before integration
• Validate API contracts
• Document external APIs

Learning & Exploration

• Explore public APIs (GitHub, Stripe, Twitter, etc.)
• Understand API structures
• Generate working code examples
• Create educational documentation

🏗️ Architecture

mcp-api-toolkit/
├── src/
│   ├── index.ts           # Main MCP server
│   ├── tools/             # MCP tool definitions
│   ├── utils/
│   │   ├── openapi-parser.ts  # OpenAPI parsing
│   │   ├── api-client.ts      # HTTP client
│   │   └── sdk-generator.ts   # SDK generation
│   └── types/
│       └── api.ts         # TypeScript types
├── examples/              # Usage examples
├── docs/                  # Documentation
└── tests/                 # Unit tests

🔒 Security

• No API credentials are stored
• All requests are made on-demand
• Rate limiting respect
• Input validation with Zod
• HTTPS-only for URL parsing

🤝 Contributing

Contributions are welcome! Please read our Contributing Guide first.

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Commit changes: git commit -m 'Add amazing feature'
4. Push to branch: git push origin feature/amazing-feature
5. Open a Pull Request

📝 License

MIT License - see LICENSE file for details

🌟 Star History

If you find this project useful, please consider giving it a star on GitHub!

🔗 Links

• Model Context Protocol
• Claude Code
• OpenAPI Specification
• Report Issues

💡 Inspiration

Built to solve the API-first development workflow in 2025. Inspired by:

• Postman's intuitive API testing
• OpenAPI's standardization
• Claude's AI-powered development assistance

📧 Support

• Documentation: docs/
• Issues: GitHub Issues
• Discussions: GitHub Discussions

---

Made with ❤️ for the Claude Code community

Supercharge your API development workflow with AI!