I Built an MCP Security Audit System with mcp-scan and Notion MCP

yazar

This is a submission for the Notion MCP Challenge

What I Built

Every AI developer using Claude Desktop, Cursor, VS Code, Windsurf, or any MCP-enabled tool has MCP servers running on their machine. These servers have direct access to your filesystem, your API keys, and your network. Most people have never audited them.

I built MCP Security Command Center: a workflow that scans all your MCP server configurations using mcp-scan, then automatically populates a structured security dashboard in Notion via Notion MCP. Every finding becomes a tracked database entry. Every server gets a status. You get a living audit trail that updates on every scan.

Running this on my own machine found 3 HIGH and 9 MEDIUM severity findings across 10 MCP servers. This included a server with both filesystem and network access (classic exfiltration vector) and an unverified package source. None of this was visible before.

The workflow:

  1. npx mcp-scan@latest --json scans all AI tool configs automatically (Claude Desktop, Cursor, VS Code, Gemini CLI, and 12 more)
  2. The JSON output gets piped into a push script that calls Notion MCP tools
  3. Notion MCP creates a database entry for each finding: server name, severity, finding type, affected AI tool, fix recommendation
  4. A summary page tracks overall security posture over time

The result is a Notion workspace that serves as your MCP security command center. Filter by severity, sort by date, assign findings to track remediation, share audit results with your team.

Video Demo

The terminal output below shows the live workflow. A screen recording is in the GitHub repo README.

Running the full pipeline: 

# Scan all MCP configs and push findings to Notion
npx mcp-scan@latest --json | node notion-integration/push-to-notion.js

Output: 

Scanning 10 MCP servers...
  + thynkq-router (Claude Code): 2 findings pushed to Notion
  + vercel (Claude Code): 2 findings pushed to Notion
  + playwright (Claude Code): 1 finding pushed to Notion
  + vercel (Gemini CLI): 1 finding pushed to Notion
  + playwright (Gemini CLI): 1 finding pushed to Notion
  + sequentialthinking (Claude Code): 1 finding pushed to Notion
  + 4 more servers scanned, 0 findings

Done: 8 created, 0 updated, 4 clean servers skipped.
Total findings tracked in Notion: 8

Show us the code

GitHub repo: github.com/rodolfboctor/mcp-scan

The Notion MCP integration lives in notion-integration/push-to-notion.js: 

import { Client } from "@notionhq/client";

const SEVERITY_COLORS = {
  CRITICAL: "red",
  HIGH:     "orange",
  MEDIUM:   "yellow",
  LOW:      "blue",
  INFO:     "gray",
};

async function main() {
  const notion = new Client({ auth: process.env.NOTION_API_KEY });
  const databaseId = process.env.NOTION_DATABASE_ID;

  let raw = "";
  for await (const chunk of process.stdin) raw += chunk;
  const { results } = JSON.parse(raw);

  for (const server of results) {
    const { serverName, toolName, configPath, findings = [] } = server;
    for (const finding of findings) {
      const { id, severity, description, fixRecommendation } = finding;

      const existing = await notion.databases.query({
        database_id: databaseId,
        filter: {
          and: [
            { property: "Server", rich_text: { equals: serverName } },
            { property: "Finding ID", rich_text: { equals: id } },
            { property: "AI Tool", rich_text: { equals: toolName } },
          ],
        },
      });

      const props = {
        Name: { title: [{ text: { content: serverName + ": " + id } }] },
        Server: { rich_text: [{ text: { content: serverName } }] },
        "AI Tool": { rich_text: [{ text: { content: toolName } }] },
        Severity: { select: { name: severity, color: SEVERITY_COLORS[severity] || "default" } },
        "Finding ID": { rich_text: [{ text: { content: id } }] },
        "Config Path": { rich_text: [{ text: { content: configPath || "" } }] },
        "Fix": { rich_text: [{ text: { content: fixRecommendation || "See mcp-scan docs" } }] },
        "Scan Date": { date: { start: new Date().toISOString() } },
      };

      if (existing.results.length > 0) {
        await notion.pages.update({ page_id: existing.results[0].id, properties: props });
      } else {
        await notion.pages.create({
          parent: { database_id: databaseId },
          properties: { ...props, Status: { select: { name: "Open" } } },
        });
      }
    }
  }
}

main().catch(console.error);

Configure Notion MCP in .mcp.json: 

{
  "mcpServers": {
    "notion": {
      "command": "npx",
      "args": ["-y", "@notionhq/notion-mcp-server"],
      "env": {
        "OPENAPI_MCP_HEADERS": "{"Authorization": "Bearer YOUR_NOTION_TOKEN"}"
      }
    }
  }
}

With this config, ask Claude:

“Run mcp-scan, then use Notion MCP to create a security database. Each row: server name, severity, finding description, affected AI tool, config path, fix recommendation.”

Claude runs both tools and populates Notion automatically.

How I Used Notion MCP

Notion MCP is the core of what makes this workflow useful instead of just informational.

mcp-scan generates great security data. The problem is that JSON in a terminal is ephemeral. You look at it once, close the terminal, and forget. Security work requires tracking, assignment, and follow-through. That is where Notion MCP comes in.

The Notion MCP server exposes tools for creating pages, querying databases, and updating properties. In this workflow it does three things:

1. Structured persistence. Each finding gets its own Notion page with typed properties: severity as a color-coded select, server name, affected AI tool, config path, fix recommendation, and scan date. Queryable and filterable in ways a text file never could be.

2. Idempotent updates. Running the scan twice does not create duplicate entries. The push script queries for existing findings by server + finding ID + tool name before writing. Run it daily, the database stays clean.

3. Remediation tracking. Each finding starts with Status: Open. Your team changes it to In Progress or Fixed as work happens. The next scan does not overwrite status fields that already have values.

The workflow becomes a closed loop: scan, review in Notion, fix, rescan, mark fixed. Same pattern security teams use for CVE tracking, applied to MCP servers.

For teams using Notion as their primary workspace, MCP security findings live alongside your project docs, backlog, and runbooks. Not in a separate tool nobody checks.

Stack:

  • mcp-scan – open-source MCP security scanner (MIT)
  • Notion MCP – official Notion MCP server
  • Node.js – push script bridge

Try it: 

npx mcp-scan@latest --json | node notion-integration/push-to-notion.js