Koskamo

NanoParse MCP

A hosted MCP server that converts any URL into clean Markdown with a 20-signal intelligence layer for AI agents. It supports full Chromium rendering for JavaScript-heavy SPAs, extracts metadata, and provides machine-readable trust signals like source authority and paywall detection. It uses a pay-per-parse model via x402 micropayments with a free tier available.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

NanoParse MCP logo, by nanoparse-devCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-06Published by nanoparse-dev
MCP endpoint (Streamable HTTP)
https://nanoparse.app/mcp
Vendor documentation

What its tools do

2 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

2 of 2 have a description · 2 of 2 declare behavior hints · 2 of 2 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Fetch any web page and get clean Markdown back
  • Check free quota, wallet and USDC balance before spending
  • Extract 20 machine-readable trust signals from content
  • Render JavaScript-heavy SPAs into structured text

Source and maintenance

Community listingRegistry 2.0.1
Maintenance checked

Protocol and capabilities

Server
nanoparse-mcp 1.0.0
MCP protocol negotiated in check
2025-11-25
Tools
2 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {}
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

NanoParse reads web pages for agents. $0.005 per parse — paid in USDC on Base via x402, with no account, no API key and no subscription. 10 free parses a month, no account and no API key; a signed wallet claims the same 10 from a cloud host. A page that cannot be read — bot wall, consent wall, paywall, PDF — is reported with a named reason and never charged. Tools: nanoparse_fetch(url, payment_signature, wallet_address?, wallet_signature?) reads one page and returns clean Markdown plus Litmus signals; nanoparse_status(address) reports quota, wallet balance and payment state. Reading many pages: one call per URL, by design. Build a URL list (the site's own sitemap.xml, or your own discovery) and call nanoparse_fetch once per URL, collecting results as you go — one page per call, charged only if the read succeeds. Budget is simply pages x $0.005. Stop any time — nothing is prepaid and nothing is held.

Tools

2 advertised

nanoparse_fetch
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Read one URL into clean Markdown with Litmus signals (source authority, freshness, structural trust). Price: $0.005 per page actually read, USDC on Base via x402. Free tier: 10 free parses a month, no account and no key. On a cloud host (where the anonymous allowance does not apply) pass wallet_address + wallet_signature once — a plain EIP-191 signature, no payment — to claim the same 10. A page we cannot read — bot wall, consent wall, paywall, PDF — is reported with a named reason and never charged. To read a whole site or a list: call this tool once per URL. Build your list first (GET https://<site>/sitemap.xml, or use URLs you already have), then loop. No minimum, no commitment, no balance to spend down: stop whenever you like. If you already know the price and the payTo address, pay on the first call and skip the 402 round trip. Otherwise, when the tool returns a payment_required error, sign the included payment_terms and retry with the payment_signature argument (works in every MCP client; no custom headers needed).

nanoparse_fetch input schema
{
  "type": "object",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "The URL to fetch and parse"
    },
    "wallet_address": {
      "type": "string",
      "description": "Your wallet address (0x...) to claim the free tier — no payment needed."
    },
    "wallet_signature": {
      "type": "string",
      "description": "EIP-191 personal_sign signature (0x... hex, 65 bytes r||s||v) over the exact string \"nanoparse.app free tier: sign this message to claim 10 free parses (no payment).\". Proves you own wallet_address and unlocks 10 free parses per month."
    },
    "payment_signature": {
      "type": "string",
      "description": "x402 payment signature — base64-encoded JSON payment terms. Only needed after the free tier is exhausted: the payment_required error response includes the payment_terms to sign. Pass the signed terms here (or as a Payment-Signature header if your client supports headers)."
    }
  }
}
nanoparse_fetch output schema
{
  "type": "object",
  "properties": {
    "content": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "type",
          "text"
        ],
        "properties": {
          "text": {
            "type": "string",
            "description": "The extracted page content as clean Markdown with GFM tables preserved"
          },
          "type": {
            "enum": [
              "text"
            ],
            "type": "string",
            "description": "Content type — always 'text' for NanoParse"
          }
        }
      },
      "description": "Array of content items returned by the tool"
    }
  },
  "description": "Returns content[0].text as clean Markdown with GFM tables, stripped of navigation, ads, and boilerplate. structuredContent carries the full parse envelope: {markdown, metadata, litmus}. On error, returns a JSON-RPC error object with code and message."
}
nanoparse_fetch annotations
{
  "title": "Read one URL into clean Markdown + Litmus",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
nanoparse_status
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Check wallet balance, USDC balance, quota state, and whether the next /fetch call will succeed without payment. Use before spending — tells the agent exactly how much to fund.

nanoparse_status input schema
{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "description": "The Ethereum wallet address to query (0x...)."
    }
  }
}
nanoparse_status output schema
{
  "type": "object",
  "required": [
    "wallet_address",
    "usdc_balance",
    "price_per_parse",
    "quota"
  ],
  "properties": {
    "quota": {
      "type": "object"
    },
    "funding_uri": {
      "type": "string"
    },
    "usdc_balance": {
      "type": "string"
    },
    "balance_error": {
      "type": [
        "string",
        "null"
      ]
    },
    "balance_known": {
      "type": "boolean"
    },
    "wallet_address": {
      "type": "string"
    },
    "price_per_parse": {
      "type": "string"
    },
    "usdc_balance_raw": {
      "type": [
        "string",
        "null"
      ],
      "description": "Balance in micro-USDC; null when the chain could not be read"
    },
    "next_call_will_succeed": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "null when the free tier is exhausted and the balance is unknown"
    },
    "estimated_parses_remaining": {
      "type": [
        "number",
        "null"
      ],
      "description": "null when the balance is unknown — never 0, which would imply an empty wallet"
    }
  },
  "description": "Machine-readable status fields. This schema describes structuredContent — strict MCP clients validate structuredContent against it, so it must NOT require the result-envelope `content` array."
}
nanoparse_status annotations
{
  "title": "Check wallet, quota and payment state",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (2 of 2 answered).

  1. 2026-11-06: 1 of 1 checks answered
  2. 2026-11-07: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
533 ms
95th percentile latency
533 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 533 ms · metadata changed · 2 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http nanoparse-mcp https://nanoparse.app/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add nanoparse-mcp --url https://nanoparse.app/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable nanoparse-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "nanoparse-mcp": {
      "url": "https://nanoparse.app/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "nanoparse-mcp": {
      "type": "streamableHttp",
      "url": "https://nanoparse.app/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start nanoparse-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "nanoparse-mcp": {
      "type": "http",
      "url": "https://nanoparse.app/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http nanoparse-mcp https://nanoparse.app/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://nanoparse.app/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "nanoparse-mcp": {
      "serverUrl": "https://nanoparse.app/mcp"
    }
  }
}

Let your agent find its tools

Find servers like NanoParse MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.