build custom mcp server with n8n

You can spin up a bespoke Model Context Protocol (MCP) server in under an hour using n8n's visual workflow engine, then expose a single HTTPS endpoint that any Claude, OpenAI Assistant, or other LLM can call to run custom tools. The result is a reusable "toolkit" that you control end-to-end, with authentication, JSON-schema validation, and error handling baked in.

What is MCP? MCP (Model Context Protocol) is a lightweight JSON contract that lets an LLM request a tool call (method, arguments) and receive a structured response (result, error). It standardises how agents communicate with external services without hard-coding provider-specific payloads.

What you need

\*Pricing details change frequently; verify the latest numbers on each provider's pricing page.

Estimated build time: 45 - 60 minutes if you already have an n8n account.

Step-by-step guide to build custom mcp server with n8n

1. Create the webhook that will receive MCP payloads

1. Log in to n8n Cloud (or spin up the Docker image).
2. Click New Workflow → Add Node → search for Webhook.
3. Set HTTP Method to POST and give the endpoint a clear path, e.g. /mcp.
4. Enable Response Mode → Respond with JSON - this tells n8n to send a JSON body back to the caller.

Why: The webhook is the public entry point the LLM will hit. Using the "Respond with JSON" mode ensures the response complies with MCP's expected shape.

2. Validate the incoming MCP request

Add a Function node after the webhook:

{
 "name": "Validate MCP",
 "type": "n8n-nodes-base.function",
 "position": [400, 200],
 "parameters": {
 "functionCode": "const schema = {\n type: 'object',\n required: ['method', 'arguments'],\n properties: {\n method: { type: 'string' },\n arguments: { type: 'object' }\n }\n};\nconst Ajv = require('ajv');\nconst ajv = new Ajv();\nconst valid = ajv.validate(schema, items[0].json);\nif (!valid) {\n throw new Error('Invalid MCP payload: ' + ajv.errorsText());\n}\nreturn items;"
 }
}

What this does: The node uses the ajv JSON-schema validator (built-in to n8n) to enforce the MCP contract before any tool logic runs. If validation fails, the workflow aborts and returns an error message.

3. Route the method to the appropriate tool

Add a Switch node, set the Value to evaluate to {{$json["method"]}}, then create one case per tool you want to expose (e.g., search_google, create_ticket). For each case, attach the corresponding tool node(s).

Why: A Switch node lets you branch the workflow without writing code, keeping the MCP server modular. Adding a new tool later is just another case.

4. Example tool: call a third-party REST API

Suppose you want a search_google tool that proxies Google's Custom Search JSON API.

1. Inside the search_google case, add an HTTP Request node. 2. Set Method → GET. 3. URL → https://www.googleapis.com/customsearch/v1. 4. Add query parameters: - key → {{ $env.GOOGLE_API_KEY }} - cx → {{ $env.SEARCH_ENGINE_ID }} - q → {{ $json["arguments"]["query"] }}

# Example of setting the required environment variables locally
export GOOGLE_API_KEY=your_google_key
export SEARCH_ENGINE_ID=your_cse_id

Result: The HTTP Request node returns Google's search results, which we'll package back into an MCP-compliant response.

5. Format the MCP response

Add a Function node after each tool's execution to shape the result:

// returns { result: <payload>, error: null }
return [
 {
 json: {
 result: $json,
 error: null
 }
 }
];

If a tool throws, catch it with an Error Trigger node and send:

return [
 {
 json: {
 result: null,
 error: $error.message
 }
 }
];

6. Wire the final response back to the webhook

Connect the last Function node of each branch to the webhook's Response output. n8n will automatically serialize the json property and send it with a 200 OK status.

7. Secure the endpoint

1. In the Webhook node, enable Authentication → Header Auth.
2. Define a secret token in n8n's Environment Variables (e.g., MCP_TOKEN).
3. Require callers to send Authorization: Bearer <MCP_TOKEN> header.

# Example curl test
curl -X POST https://your-n8n-instance.com/webhook/mcp \
 -H "Authorization: Bearer $(echo $MCP_TOKEN)" \
 -H "Content-Type: application/json" \
 -d '{"method":"search_google","arguments":{"query":"n8n tutorials"}}'

Why: Header authentication is simple, works with any LLM client, and avoids exposing a public API key.

8. Register the tool with the LLM

#### OpenAI Assistant example

{
 "name": "search_google",
 "description": "Search Google via a custom search engine.",
 "parameters": {
 "type": "object",
 "properties": {
 "query": {
 "type": "string",
 "description": "Search terms"
 }
 },
 "required": ["query"]
 },
 "type": "function",
 "function": {
 "name": "search_google",
 "url": "https://your-n8n-instance.com/webhook/mcp",
 "method": "POST",
 "authorization": {
 "type": "Bearer",
 "token": "YOUR_MCP_TOKEN"
 }
 }
}

Paste this JSON into the Tools section of the OpenAI Assistant UI (see the official OpenAI Assistants tools documentation). The assistant will now be able to invoke search_google through the MCP server you just built.

#### Claude example

Claude expects a similar tool definition in the tool field of the request payload. Follow Anthropic's guide for function calling and point the URL to the same webhook.

Where this breaks

Key warning: Because the MCP server forwards any JSON payload to downstream services, always whitelist the domains you call. An open-ended method field could become an attack vector if you ever expose the endpoint to untrusted users.