How do I use nodemaven-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@nodemaven-mcp Fetch this page as a US shopper in New York and tell me the price." That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

nodemaven-mcp

by Artirain

Overview Schema Source Related Servers Discussions Admin

Python

Remote

nodemaven-mcp

Python 3.10+ License: MIT

English | Русский

Give your AI agent a residential IP. An MCP server that lets Claude Code, Claude Desktop, Cursor or any other MCP client route web requests through NodeMaven residential and mobile proxies: pick an exit country, verify what the target site sees, and pull the page.

you:    read this product page the way a shopper in Munich sees it
agent:  nodemaven_fetch(url=..., country="de", city="munich")
        -> 200, de, 14.99 EUR, exit IP 91.34.x.x (Vodafone), 812 ms

Unofficial, community-built, MIT licensed. Not affiliated with NodeMaven.

Why

Agents are increasingly the thing doing the browsing, and they hit the same wall everyone else does: datacenter IPs get blocked, and prices, stock and search results change by geography. The proxy is already the fix - it just isn't reachable from inside the agent's session.

This server closes that gap in five tools. Nothing here needs a scraping DSL: the agent asks for a country, gets a working connection, and reads the page.

Related MCP server: proxyclaw-mcp-py

Tools

Tool	What it does	Needs
`nodemaven_build_proxy_url`	Builds a proxy URL with geo targeting encoded in the username, ready for curl, Playwright, Scrapy or requests	proxy creds
`nodemaven_check_proxy`	One request through the proxy: exit IP, geo, ISP, latency	proxy creds
`nodemaven_fetch`	Fetches a URL through the proxy, HTML converted to readable text	proxy creds
`nodemaven_list_locations`	Countries, regions, cities, ISPs, zip codes available for targeting	API key
`nodemaven_get_usage`	Traffic consumed, request counts, per-domain breakdown	API key

Every tool takes response_format: markdown (default, compact) or json (complete, for programmatic use), and paginates with limit / offset.

Install

git clone https://github.com/Artirain/nodemaven-mcp
cd nodemaven-mcp
pip install -e .

Requires Python 3.10+.

Configure

Two independent sets of credentials, both from the NodeMaven dashboard:

NODEMAVEN_API_KEY - Profile -> API Key. Used by the location and usage tools.
NODEMAVEN_PROXY_USERNAME / NODEMAVEN_PROXY_PASSWORD - Proxy Setup. Used by everything that sends traffic through the proxy.

You can set only one set; tools that need the other say so instead of failing silently.

Claude Code

claude mcp add nodemaven \
  -e NODEMAVEN_API_KEY=... \
  -e NODEMAVEN_PROXY_USERNAME=... \
  -e NODEMAVEN_PROXY_PASSWORD=... \
  -- python -m nodemaven_mcp

Claude Desktop / Cursor

claude_desktop_config.json (or .cursor/mcp.json):

{
  "mcpServers": {
    "nodemaven": {
      "command": "python",
      "args": ["-m", "nodemaven_mcp"],
      "env": {
        "NODEMAVEN_API_KEY": "your-api-key",
        "NODEMAVEN_PROXY_USERNAME": "your-proxy-username",
        "NODEMAVEN_PROXY_PASSWORD": "your-proxy-password"
      }
    }
  }
}

A local .env in the working directory also works - see .env.example. Environment variables always win over the file.

On Windows, give the absolute path to python.exe rather than bare python. If Python came from the Microsoft Store, the python on your PATH is an app execution alias that MCP clients cannot spawn, and the server silently never appears. python -c "import sys; print(sys.executable)" prints the path to use.

Use it

Three things worth asking your agent, once it is connected:

Check what a site sees

"Am I actually coming out of Germany? Use a Vodafone IP if you can."

The agent calls nodemaven_check_proxy(country="de", isp="vodafone") and reports the exit IP, city and latency. Useful as a smoke test before a long run.

Read geo-restricted content

"Fetch this page as a US shopper in New York and tell me the price."

nodemaven_fetch(url=..., country="us", city="new york") returns readable text, truncated to 200 KB by default so it does not flood the context.

Keep one identity across a flow

"Log into the demo account and walk through checkout, same IP the whole time."

Pass the same session_id (4-10 alphanumerics) on every call and NodeMaven pins the exit IP; drop it and the IP rotates per request.

Targeting spellings matter. nodemaven_list_locations(level="cities", country="de") gives the exact values NodeMaven accepts, which is the difference between a working pool and an empty one.

See what it actually does

A tool call is easy to trust and hard to verify. examples/traffic_dashboard.py runs a local forward proxy with a live dashboard, so you can point the server at it and watch every hop it makes:

python examples/traffic_dashboard.py     # proxy on :8080, dashboard on :8099

NODEMAVEN_PROXY_HOST=127.0.0.1
NODEMAVEN_HTTP_PORT=8080

Dashboard showing proxy hops with decoded targeting

Each row is a real network request. The route column is decoded from the proxy username, which is exactly the string NodeMaven uses to choose the exit IP - so you can confirm that country="de", city="Munich" in a tool call really did leave your machine as DE / MUNICH, and that a session_id stayed pinned across calls.

The dashboard is a development aid: it accepts any credentials and does not encrypt anything. Do not put it on a network you share.

Design notes

Passwords stay masked. build_proxy_url returns *** in place of the password unless the caller passes reveal_credentials=true. Transcripts get shared, pasted into issues and fed back into models; a proxy password should not ride along by default.

Errors are written for an agent, not a log file. A refused connection says that an over-narrow city or ISP filter is the usual cause and suggests widening it. A 401 names the environment variable to check. An agent that can read the error can retry correctly on the first attempt.

Targeting is pure and tested. NodeMaven encodes location in the proxy username:

acct-country-us-region-california-city-los_angeles-isp-t_mobile_usa-sid-ab12cd-filter-medium

Building that string - normalizing "Los Angeles" to los_angeles, rejecting a session id that would silently disable stickiness, validating the port against the range for the chosen protocol - is pure logic, so it is covered by tests that never touch the network.

No parser dependency. HTML-to-text runs on html.parser from the standard library. The dependency list is mcp, httpx and pydantic.

Development

pip install -e ".[dev]"
pytest -q          # 60 tests, no network, no credentials needed
ruff check .

CI runs the suite on Python 3.10, 3.11 and 3.12.

Contributions welcome - see CONTRIBUTING.md.

License

MIT

Available Tools

5 tools

nodemaven_build_proxy_urlA

Read-onlyIdempotent

Build a NodeMaven proxy URL with geo targeting encoded in the username.

Use this to hand a ready connection string to another tool - curl, Playwright, Scrapy, requests - instead of guessing NodeMaven's username syntax. No network call is made. To verify the IP actually works, use nodemaven_check_proxy.

Returns: str: Markdown or JSON with the schema: { "proxy_url": str, # e.g. "http://user-country-us-sid-ab12:***@gate.nodemaven.com:8080" "username": str, # targeting username "host": str, "port": int, "protocol": str, "password_masked": bool } On failure: "Error: "

Examples: - "give me a US proxy string for curl" -> country='us', reveal_credentials=true - "same IP for the whole login flow" -> session_id='ab12cd' - Don't use when: you want the page content (use nodemaven_fetch instead)

ParametersJSON Schema

Name	Required	Description	Default
`isp`	No	ISP or mobile carrier to pin, e.g. 't-mobile usa'.
`city`	No	City to narrow the pool, e.g. 'los angeles'.
`port`	No	Override the proxy port. Defaults to the port set for the protocol.
`region`	No	State or region to narrow the pool, e.g. 'california'.
`country`	Yes	Two-letter ISO country code for the exit IP, e.g. 'us', 'de', 'br'.
`protocol`	No	Proxy protocol: 'http' or 'socks5'.	http
`ipv4_only`	No	Restrict the exit IP to IPv4.
`session_id`	No	4-10 alphanumeric characters. Reuse the same value to keep the same exit IP across calls (sticky session); omit it to rotate on every request.
`response_format`	No	'markdown' for a compact summary, 'json' for the full payload.	markdown
`ip_quality_filter`	No	NodeMaven IP quality tier, e.g. 'medium' or 'high'.
`reveal_credentials`	No	Include the real proxy password in the returned URL. Keep false unless the URL goes straight to a command that must authenticate; the password otherwise stays masked so it does not leak into transcripts.

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses that no network call is made, which is essential behavioral context. It also specifies the return format, includes a failure string pattern, and implies password masking through the output schema. This adds meaningful transparency beyond structured annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a concise opening sentence, a return schema block, examples, and an exclusion note. It is somewhat long, and the included return schema duplicates what an output schema likely already provides, but every section serves a practical purpose and the first sentence carries the core intent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (11 parameters, rich schema, sibling alternatives), the description is complete: it states the use case, clarifies the no-network-call behavior, gives concrete examples for parameter usage, and warns when not to use it. The combination of schema, annotations, and description leaves no major gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already covers 100% of parameters, so the baseline is 3. The description adds valuable examples mapping natural language to parameters (e.g., 'give me a US proxy string for curl' -> country='us', reveal_credentials=true) and explains the session_id sticky-IP behavior. This goes beyond the schema, but not all 11 parameters receive extra semantic detail.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Build a NodeMaven proxy URL with geo targeting encoded in the username.' It uses a specific verb and resource, and the sibling tools (nodemaven_check_proxy, nodemaven_fetch, etc.) are distinct in purpose, so there is no ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit when-to-use guidance: hand a ready connection string to other tools like curl, Playwright, Scrapy, or requests. It also provides clear alternatives: use nodemaven_check_proxy to verify the IP works, and nodemaven_fetch when page content is needed. This fully satisfies the dimension.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

nodemaven_check_proxyA

Read-only

Send one request through the proxy and report the exit IP, its geo and latency.

Use this before a scraping run to confirm the targeting resolves to a real pool and that the exit IP is where you expect. Over-narrow targeting (a rare city plus an ISP filter) is the usual reason a connection fails.

Returns: str: Markdown or JSON with the schema: { "exit_ip": str, # e.g. "104.28.51.7" "country": str, # e.g. "US" "region": str, "city": str, "org": str, "latency_ms": int, "proxy": str, # password-masked proxy URL "session_id_used": bool } On failure: "Error: "

Examples: - "am I really coming out of Germany?" -> country='de' - "does this sticky session hold?" -> session_id='ab12cd', call twice - Don't use when: you need the catalogue of available cities (use nodemaven_list_locations)

ParametersJSON Schema

Name	Required	Description	Default
`isp`	No	ISP or mobile carrier to pin, e.g. 't-mobile usa'.
`city`	No	City to narrow the pool, e.g. 'los angeles'.
`port`	No	Override the proxy port. Defaults to the port set for the protocol.
`region`	No	State or region to narrow the pool, e.g. 'california'.
`country`	Yes	Two-letter ISO country code for the exit IP, e.g. 'us', 'de', 'br'.
`protocol`	No	Proxy protocol: 'http' or 'socks5'.	http
`ipv4_only`	No	Restrict the exit IP to IPv4.
`session_id`	No	4-10 alphanumeric characters. Reuse the same value to keep the same exit IP across calls (sticky session); omit it to rotate on every request.
`response_format`	No	'markdown' for a compact summary, 'json' for the full payload.	markdown
`ip_quality_filter`	No	NodeMaven IP quality tier, e.g. 'medium' or 'high'.

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses that exactly one request is sent, describes the return schema and failure format, and notes that over-narrow targeting is a common failure cause. Annotations already mark it read-only, so the description adds beyond by explaining operational behavior. No contradiction.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a clear opening, usage context, return schema, examples, and an exclusion. Each section earns its place, and it is not excessively verbose for a tool with 10 parameters.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (10 parameters), the description covers purpose, use cases, failure behavior, return format, and a sibling alternative. The schema and annotations supply parameter and safety details, so the description is contextually complete for an agent to select and invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although schema descriptions cover all parameters (100%), the description adds meaning with concrete examples: using country='de' to test exit country, and session_id='ab12cd' to test sticky sessions. It also explains the interplay of city and ISP for targeting. This goes beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Send one request through the proxy') and clearly states the output (exit IP, geo, latency). It also distinguishes from sibling nodemaven_list_locations by explicitly stating when not to use it. This fulfills purpose clarity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states 'Use this before a scraping run to confirm...' and provides a 'Don't use when' with an alternative tool. This gives clear when-to-use and when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

nodemaven_fetchA

Read-only

Fetch a URL through a NodeMaven residential or mobile IP and return its content.

Use this when a page is geo-restricted or blocks datacenter traffic. HTML is converted to readable text by default so it does not flood the context; set as_text=false when the markup itself matters.

Returns: str: Markdown or JSON with the schema: { "url": str, # final URL after redirects "status_code": int, "content_type": str, "title": str | None, # HTML when available "latency_ms": int, "truncated": bool, "bytes": int, "body": str, "proxy": str # password-masked proxy URL } On failure: "Error: "

Examples: - "read this page as a German visitor" -> url=..., country='de' - "check the price shown to US shoppers" -> url=..., country='us', city='new york' - Don't use when: the site is reachable without a proxy (use a plain fetch)

ParametersJSON Schema

Name	Required	Description	Default
`isp`	No	ISP or mobile carrier to pin, e.g. 't-mobile usa'.
`url`	Yes	Absolute http(s) URL to fetch through the proxy.
`city`	No	City to narrow the pool, e.g. 'los angeles'.
`port`	No	Override the proxy port. Defaults to the port set for the protocol.
`region`	No	State or region to narrow the pool, e.g. 'california'.
`as_text`	No	Strip HTML markup and return readable text instead of raw HTML.
`country`	Yes	Two-letter ISO country code for the exit IP, e.g. 'us', 'de', 'br'.
`protocol`	No	Proxy protocol: 'http' or 'socks5'.	http
`ipv4_only`	No	Restrict the exit IP to IPv4.
`max_bytes`	No	Truncate the response body to this many bytes.
`session_id`	No	4-10 alphanumeric characters. Reuse the same value to keep the same exit IP across calls (sticky session); omit it to rotate on every request.
`response_format`	No	'markdown' for a compact summary, 'json' for the full payload.	markdown
`ip_quality_filter`	No	NodeMaven IP quality tier, e.g. 'medium' or 'high'.

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already establish the tool as readOnly and non-destructive, but the description adds substantial behavioral context beyond that: HTML is converted to readable text by default, responses can be truncated, error messages include remediation details, and the full return schema is provided with fields like truncated and proxy. This gives the agent a clear picture of what to expect.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with distinct sections for purpose, usage, return schema, examples, and an explicit anti-caveat. It is somewhat lengthy due to the included return schema, but every section earns its place and the front-loaded purpose/usage makes it efficient to scan.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (13 parameters, rich output), the description is complete: it covers purpose, when to use, return format, error behavior, and examples. The schema provides full parameter documentation, and the description's output schema and 'Don't use' guidance seal any gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema covers 100% of parameters, so baseline is 3. The description adds meaningful usage examples for country and city (e.g., country='de' for German visitor), and clarifies the as_text parameter's behavior. However, it does not discuss all parameters, so the schema remains the primary source for many.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool fetches a URL through a NodeMaven proxy and returns content. It distinguishes this from sibling tools like nodemaven_build_proxy_url and nodemaven_check_proxy by focusing on the actual fetch operation. Examples reinforce the purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit 'Use this when' (geo-restricted or blocks datacenter traffic) and 'Don't use when' (site reachable without a proxy) guidance. Also gives contextual examples such as 'read this page as a German visitor' and 'check the price shown to US shoppers' to illustrate parameter usage. Indicates when to set as_text=false for markup.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

nodemaven_get_usageA

Read-onlyIdempotent

Report account usage: traffic consumed, request counts or per-domain breakdown.

Use this to check remaining traffic before a large run, or to attribute spend to the domains that caused it.

Returns: str: Markdown or JSON with the same pagination envelope as nodemaven_list_locations, where items are usage records. On failure: "Error: "

Examples: - "how much traffic have I burned?" -> kind='data' - "which domains cost me the most?" -> kind='domains'

Requires NODEMAVEN_API_KEY.

ParametersJSON Schema

Name	Required	Description	Default
`kind`	No	'data' for traffic consumption, 'requests' for request counts, 'domains' for per-domain usage.	data
`limit`	No	Maximum records to return.
`offset`	No	Records to skip, for pagination.
`response_format`	No	'markdown' for a compact summary, 'json' for the full payload.	markdown

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds meaningful behavioral context beyond the annotations: it requires NODEMAVEN_API_KEY, explains the return format as Markdown or JSON with the same pagination envelope as nodemaven_list_locations, and specifies the failure format. These details help the agent understand side effects, prerequisites, and error handling beyond what readOnlyHint/idempotentHint already convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured and front-loaded: first line states the main purpose, followed by when-to-use, return format, examples, and auth requirement. Each section earns its place, and the total length is appropriate for the tool's complexity. No redundant or filler content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only reporting tool with well-described schema and annotations, the description covers all necessary aspects: purpose, usage scenarios, return type and format, error behavior, and authentication. It also references the pagination envelope from nodemaven_list_locations, making the integration contract clear without over-explaining.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description adds value by providing concrete usage examples that map natural language queries to specific 'kind' values ('how much traffic have I burned?' -> kind='data'). This helps the agent select the correct parameter values, exceeding the bare schema definitions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Report account usage: traffic consumed, request counts or per-domain breakdown.' This is a specific verb+resource combination that distinguishes it from siblings like nodemaven_build_proxy_url or nodemaven_fetch. The examples further clarify what the tool does.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says when to use the tool: 'Use this to check remaining traffic before a large run, or to attribute spend to the domains that caused it.' It does not explicitly state when not to use it or name alternative tools, but the context is clear and specific enough for an agent to decide appropriately.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

nodemaven_list_locationsA

Read-onlyIdempotent

List the countries, regions, cities, ISPs or zip codes available for targeting.

Use this to discover exact spellings before targeting - guessing a city name is the most common reason a proxy connection returns an empty pool.

Returns: str: Markdown or JSON with the schema: { "total": int, "count": int, "offset": int, "limit": int, "has_more": bool, "next_offset": int | None, "items": [ { ... } ] # raw records as returned by NodeMaven } On failure: "Error: "

Examples: - "which countries can I target?" -> level='countries' - "list German cities" -> level='cities', country='de' - "which carriers exist in the US?" -> level='isps', country='us'

Requires NODEMAVEN_API_KEY.

ParametersJSON Schema

Name	Required	Description	Default
`level`	No	One of: countries, regions, cities, isps, zipcodes.	countries
`limit`	No	Maximum records to return.
`offset`	No	Records to skip, for pagination.
`region`	No	Region name scoping cities.
`country`	No	Two-letter country code scoping regions, cities, ISPs or zip codes.
`response_format`	No	'markdown' for a compact summary, 'json' for the full payload.	markdown

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds substantial behavioral context beyond annotations: the exact return structure (Markdown/JSON with schema), failure format ('Error: ...'), API key requirement, and the practical consequence of incorrect spellings. It does not contradict the read-only/idempotent annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured and front-loaded with the core purpose. It flowssections for usage guidance, return schema, examples, and requirement, with no redundant sentences. The length is appropriate for the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a discovery tool with six optional parameters and an output schema, the description is complete: it covers purpose, when to use, return format, error handling, API key requirement, and provides examples. The schema covers parameter details, so no important gaps remain.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3. The description enriches parameter understanding with examples like 'list German cities' -> level='cities', country='de', and mentions response_format implicitly via 'Markdown or JSON'. This adds value beyond the schema's individual parameter descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states that the tool lists available targeting locations (countries, regions, cities, ISPs, zip codes), using a specific verb and resource. It also distinguishes itself from sibling tools by its focus on location discovery before targeting.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly says to use this tool to discover exact spellings before targeting and warns against guessing, which causes empty pools. It provides concrete examples mapping intents to parameter values. However, it does not explicitly mention when not to use it or compare with alternative tools, so it falls just short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

5 tool updatesv0.1.0Jul 31, 2026
- First observednodemaven_build_proxy_url
- First observednodemaven_check_proxy
- First observednodemaven_fetch
- First observednodemaven_get_usage
- First observednodemaven_list_locations

Deploy Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.8/5.0

Scored 2026-07-31 19:01 across 5 tools

Disambiguation5/5

Each tool has a clearly distinct role: building a proxy URL, testing a proxy, fetching content, listing targeting locations, and retrieving usage. No two tools overlap in purpose, and the descriptions reinforce the boundaries.

Naming Consistency5/5

All tool names follow a consistent `nodemaven_<verb>_<object>` pattern with lowercase snake_case. Verbs (build, check, fetch, list, get) are distinct and predictable, making the set easy to navigate.

Tool Count5/5

The server has 5 tools, which is well-scoped for a proxy management domain. Each tool earns its place, covering the essential operations without unnecessary bloat or redundancy.

Completeness5/5

The tool set covers the full proxy lifecycle: discover targeting options, construct a proxy URL, verify it works, fetch content through it, and monitor usage. There are no obvious dead ends or missing critical operations.

Maintenance

ActivitySlowing

ResponsivenessUnresponsive

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

agentwork-mcp A
io.github.ferm-ai
Official MCP server for Agentwork — delegate tasks to AI agents with human-in-the-loop
Agent Orchestration Autonomous Agents App Automation
2
OpenClaw MCP Ecosystem
io.github.yedanyagamiai-cmd
9 remote MCP servers on Cloudflare Workers for AI agents. Free tier + Pro API keys.
Agent Orchestration Cloud Platforms RAG Systems
3
MCP Aggregation Gateway — 22k+ MCP search & call A
cn.pianam.mcp
One AI endpoint to search and call 22k+ MCP servers; 50+ hosted tools work instantly, no key.
Agent Orchestration Search
31
UnifAPIOAuth
com.unifapi
Hosted MCP server for live public-data APIs and Skills for AI agents.
Open Data Search AI & Machine Learning
2

Related MCP Servers

scraperapi-mcp-serverofficial
Web Scraping Browser Automation
scraperapi
A
license
A
quality
B
maintenance
A local MCP server that lets AI agents bypass bot detection, geo-restrictions, and JavaScript rendering challenges when scraping the web, backed by ScraperAPI's services
Updated 2 months ago (2026-07-17 14:31 UTC)
28
5
MIT
proxyclaw-mcp-py
Browser Automation Web Scraping
Iploop
A
license
Not graded
quality
D
maintenance
MCP server giving AI agents controlled residential-proxy web access with optional browser rendering and structured extraction from 60+ sites.
Updated 5 months ago (2026-04-26 15:04 UTC)
1
MIT
ma-browser
Browser Automation Web Scraping
zzhan111
A
license
Not graded
quality
A
maintenance
MCP server that lets AI agents use your real browser as an API, accessing any website with your login state, no keys or scrapers needed.
Updated 3 days ago (2026-09-10 11:43 UTC)
1
MIT
MCProxy
Web Scraping Networking & Infrastructure
evgenygurin
A
license
A
quality
C
maintenance
An MCP server that gives AI agents on-demand access to proxies from the world's leading and Russian/CIS proxy providers — through a single, unified interface.
Updated 3 months ago (2026-06-22 11:17 UTC)
11
MIT

nodemaven-mcp

Why

Tools

Install

Configure

Claude Code

Claude Desktop / Cursor

Use it

See what it actually does

Design notes

Development

License

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

scraperapi-mcp-serverofficial