MCP Fetch MCP 서버 | PlugMCP본문으로 건너뛰기MCP Fetch
A Model Context Protocol server providing tools for HTTP requests, GraphQL queries, WebSocket connections, and browser automation using Puppeteer.
Configuration
Add this to your MCP settings configuration file:
{
"mcp-fetch": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"mcp-fetch"
]
}
}
A Model Context Protocol server providing tools for HTTP requests, GraphQL queries, WebSocket connections, and browser automation
2026-10-28Installation
If the puppeteer tool is not working, remember to install the chrome browser
npx puppeteer browsers install chrome
Features
- HTTP Requests: Perform HTTP requests with full control over method, headers, and body
- GraphQL Client: Execute queries/mutations and introspect GraphQL schemas
- WebSocket Management: Connect, send, receive messages, and manage WebSocket connections
- Browser Automation: Launch browsers, create pages, and execute JavaScript using Puppeteer
- Comprehensive Docs: AI-ready documentation via
get-rules tool
Available Tools
HTTP Requests
fetch
Perform HTTP requests with full control over method, headers, body, and other fetch options.
url (string, required): The URL to fetch from
method (string, optional): HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS). Default: "GET"
headers (object, optional): HTTP headers as key-value pairs
body (string, optional): Request body for POST, PUT, PATCH, DELETE
mode (string, optional): Request mode (cors, no-cors, same-origin)
credentials (string, optional): Credentials mode (omit, same-origin, include)
cache (string, optional): Cache mode (default, no-store, reload, no-cache, force-cache, only-if-cached)
redirect (string, optional): Redirect handling (follow, error, manual). Default: "follow"
referrer (string, optional): Referrer URL
referrerPolicy (string, optional): Referrer policy
timeout (number, optional): Request timeout in milliseconds
followRedirects (boolean, optional): Whether to follow redirects. Default: true
{
"status": 200,
"statusText": "OK",
"headers": { "content-type": "application/json" },
"body": "Response body as string",
"redirected": false,
"url": "https://api.example.com/data"
}
// Simple GET request
fetch({ url: "https://api.example.com/users" })
// POST request with JSON body
fetch({
url: "https://api.example.com/users",
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ name: "John Doe", email: "[email protected]" })
})
// Request with authentication and timeout
fetch({
url: "https://api.example.com/protected",
headers: { "Authorization": "Bearer token123" },
timeout: 5000
})
GraphQL
graphql
Execute GraphQL queries and mutations with support for variables and custom headers.
action (object, required): Action to perform with discriminated union:
- For execution:
type: "execute"
endpoint (string): GraphQL endpoint URL
query (string): GraphQL query or mutation string
variables (object, optional): Variables for the query/mutation
headers (object, optional): HTTP headers (e.g., authorization)
operationName (string, optional): Operation name when query contains multiple operations
timeout (number, optional): Request timeout in milliseconds. Default: 30000
- For introspection:
type: "introspect"
endpoint (string): GraphQL endpoint URL
headers (object, optional): HTTP headers
action (string): What to fetch: "full-schema", "list-operations", or "get-type"
typeName (string, optional): Type name (required when action is "get-type")
useCache (boolean, optional): Use cached schema if available. Default: true
cacheTTL (number, optional): Cache time-to-live in milliseconds. Default: 300000
{
"data": { "user": { "id": "1", "name": "John Doe" } },
"errors": [],
"extensions": {}
}
{
"operations": {
"queries": ["getUser", "listUsers"],
"mutations": ["createUser", "updateUser"],
"subscriptions": []
}
}
// Execute a query
graphql({
action: {
type: "execute",
endpoint: "https://api.example.com/graphql",
query: `
query GetUser($id: ID!) {
user(id: $id) {
id
name
email
}
}
`,
variables: { id: "123" },
headers: { "Authorization": "Bearer token123" }
}
})
// Introspect schema
graphql({
action: {
type: "introspect",
endpoint: "https://api.example.com/graphql",
action: "list-operations"
}
})
WebSocket
socket
Manage WebSocket connections - connect, send, receive messages, list connections, and close.
action (object, required): Action to perform with discriminated union:
- For listing connections:
- For connecting:
type: "connect"
url (string): WebSocket URL (ws:// or wss://)
protocols (array, optional): WebSocket subprotocols
headers (object, optional): HTTP headers for connection
autoReconnect (boolean, optional): Auto-reconnect on disconnection. Default: false
maxReconnectAttempts (number, optional): Max reconnection attempts. Default: 5
reconnectInterval (number, optional): Base reconnect interval in ms. Default: 1000
messageHistoryLimit (number, optional): Max messages to keep. Default: 100
- For sending:
type: "send"
socketId (string): Socket connection ID
message (string or object): Message to send
binary (boolean, optional): Send as binary data. Default: false
- For receiving:
type: "receive"
socketId (string): Socket connection ID
action (string): "get-latest", "get-all", or "get-since"
since (string, optional): ISO timestamp for get-since
clearAfterRead (boolean, optional): Clear queue after reading. Default: false
- For closing:
type: "close"
socketId (string): Socket connection ID
code (number, optional): Close code. Default: 1000
reason (string, optional): Close reason. Default: "Normal closure"
{
"socketId": "ws_1234567890_abc123",
"url": "wss://example.com/socket",
"readyState": "OPEN",
"protocol": "",
"messageCount": 0
}
// Connect to WebSocket
socket({
action: {
type: "connect",
url: "wss://example.com/socket",
headers: { "Authorization": "Bearer token123" },
autoReconnect: true
}
})
// Send message
socket({
action: {
type: "send",
socketId: "ws_1234567890_abc123",
message: { type: "subscribe", channel: "updates" }
}
})
// Receive messages
socket({
action: {
type: "receive",
socketId: "ws_1234567890_abc123",
action: "get-latest"
}
})
Browser Automation
puppeteer
Control browsers and pages with Puppeteer - launch/close browsers, open/close pages, execute JavaScript, and more.
action (object, required): Action to perform with discriminated union:
- For listing browsers:
- For launching browser:
type: "launch-browser"
headless (boolean, optional): Run in headless mode. Default: false
width (number, optional): Window width. Default: 1280
height (number, optional): Window height. Default: 720
url (string, optional): URL to navigate to after launch
- For closing browser:
type: "close-browser"
browserId (string): Browser instance ID
- For listing pages:
- For opening page:
type: "open-page"
browserId (string): Browser instance ID
url (string, optional): URL to navigate to
- For closing page:
type: "close-page"
pageId (string): Page ID
- For executing code:
type: "exec-page"
pageId (string): Page ID
source (string): JavaScript code to execute (has access to page object)
Returns:
For launch-browser:
{
"success": true,
"browserId": "browser_1234567890_abc123",
"message": "Browser launched successfully",
"config": {
"headless": false,
"width": 1280,
"height": 720
}
}
// Launch browser and navigate
puppeteer({
action: {
type: "launch-browser",
headless: false,
url: "https://example.com"
}
})
// Execute page automation
puppeteer({
action: {
type: "exec-page",
pageId: "page_id",
source: `
await page.goto('https://example.com');
await page.type('#search', 'hello world');
await page.click('#submit');
const title = await page.title();
return title;
`
}
})
Documentation
get-rules
Get comprehensive documentation about this MCP server.
random_string (string): Dummy parameter for no-parameter tools
Returns: Complete documentation including schemas, use cases, and best practices.
Use Cases
API Integration
Use the fetch tool to integrate with REST APIs, webhooks, and external services.
// Fetch data from REST API
fetch({
url: "https://api.github.com/users/octocat",
headers: { "Accept": "application/vnd.github.v3+json" }
})
// Submit form data
fetch({
url: "https://api.example.com/submit",
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: "name=John&[email protected]"
})
GraphQL Operations
Use the graphql tool for type-safe API queries and schema exploration.
// Query user data
graphql({
action: {
type: "execute",
endpoint: "https://api.example.com/graphql",
query: `query { users { id name email } }`
}
})
// Explore available operations
graphql({
action: {
type: "introspect",
endpoint: "https://api.example.com/graphql",
action: "list-operations"
}
})
Real-time Communication
Use the socket tool for WebSocket connections, chat applications, and live data feeds.
// Connect to chat server
socket({
action: {
type: "connect",
url: "wss://chat.example.com",
autoReconnect: true
}
})
// Subscribe to live updates
socket({
action: {
type: "send",
socketId: "socket_id",
message: { action: "subscribe", topics: ["news", "alerts"] }
}
})
Web Automation
Use the puppeteer tool for web scraping, automated testing, and browser interactions.
// Automated form submission
puppeteer({
action: {
type: "exec-page",
pageId: "page_id",
source: `
await page.goto('https://forms.example.com');
await page.type('#name', 'John Doe');
await page.type('#email', '[email protected]');
await page.click('#submit');
await page.waitForNavigation();
return page.url();
`
}
})
// Screenshot generation
puppeteer({
action: {
type: "exec-page",
pageId: "page_id",
source: `
await page.goto('https://example.com');
const screenshot = await page.screenshot({ encoding: 'base64' });
return screenshot;
`
}
})
Best Practices
General
- Always handle errors - Wrap operations in try-catch blocks
- Use appropriate timeouts - Set reasonable timeouts for network operations
- Clean up resources - Close connections when done (browsers, websockets)
- Follow rate limits - Respect API rate limits and add delays if needed
HTTP & GraphQL
- Use proper headers - Set Content-Type, Accept, and Authorization headers
- Handle redirects appropriately - Consider security implications
- Validate responses - Check status codes and response formats
- Use HTTPS - Always prefer secure connections
WebSockets
- Implement reconnection logic - Use autoReconnect for critical connections
- Handle connection states - Check readyState before sending
- Process messages efficiently - Clear message queues regularly
- Use appropriate close codes - Follow WebSocket close code standards
Browser Automation
- Use headless mode for automation - Better performance and resource usage
- Wait for elements - Use waitForSelector before interacting
- Handle navigation - Use waitForNavigation after clicks
- Limit concurrent browsers - Avoid resource exhaustion
- Clean up pages and browsers - Prevent memory leaks
Installation
Dependencies are automatically installed when running the server. If you encounter issues:
# For browser automation (Puppeteer)
npx puppeteer browsers install chrome
# For all dependencies
npm install mcp-fetch
Limitations
- Browser instances and WebSocket connections are stored in memory and lost on restart
- Each browser instance consumes significant system resources
- WebSocket message history is limited by messageHistoryLimit
- GraphQL introspection cache is temporary and cleared on restart
- File uploads are not directly supported (use base64 encoding in body)
License
아직 도구 목록이 없습니다. 원격 서버는 첫 상태 확인 후에 도구 목록이 생깁니다.
MCP Fetch은(는) 어떻게 설치하나요?
이 페이지에서 Cursor, Claude Desktop, Claude Code 또는 VS Code용 stdio 설정을 복사합니다. PlugMCP 프록시가 아니라 게시자의 설치 방식을 사용합니다.
MCP Fetch에 API 키가 필요한가요?
이 레코드에는 필수 환경 변수가 등록되어 있지 않습니다.
MCP Fetch은(는) 어떤 전송 방식을 사용하나요?
MCP Fetch은(는) stdio를 통해 로컬에서 실행됩니다.
MCP Fetch은(는) 마지막으로 언제 확인되었나요?
마지막 확인: 2026-10-28. A Model Context Protocol server providing tools for HTTP requests, GraphQL queries, WebSocket connections, and browser automation
도구
10점 중 0점