Koskamo

Geonode MCP Server

An official MCP server provided by Geonode that allows AI assistants to interact with Geonode's web scraping infrastructure. It enables agents to extract webpage content, crawl sites, map URLs, search the web, and manage batch jobs using Geonode's proxy network and APIs.

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.

Geonode MCP Server logo, by GeonodeVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-01Operated by Geonode
You need:Add a Geonode API key for Map, Crawl, Search, batch jobs, JavaScript rendering and country targeting.You can point an MCP client at https://mcp.geonode.com/mcp with no API key and use the extract tool under free anonymous limits.
MCP endpoint (Streamable HTTP)
https://mcp.geonode.com/mcp
Vendor documentation

What you can do with it

  • Extract content from individual web pages
  • Crawl websites and documentation portals
  • Search the web for structured results
  • Process hundreds of URLs in batch jobs

Source and maintenance

Vendor evidenceRegistry 1.0.1
Maintenance checked

Protocol and capabilities

Server
Scraper API 1.0.1
MCP protocol
2025-06-18
Tools
16 advertised
Resources
0 advertised
Resource templates
0 advertised
Prompts
0 advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  },
  "prompts": {
    "listChanged": false
  },
  "resources": {
    "subscribe": false,
    "listChanged": false
  },
  "experimental": {}
}

Server-provided instructions

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

Every tool is listed, but without an API key only `extract` runs. Without an API key, extraction is synchronous only, without JavaScript rendering or request headers other than Accept-Language, and limited to a small per-client rate and daily volume. An API key, sent as the X-Api-Key header, lifts these restrictions; the plan's own limits apply instead. The other tools require an API key.

Tools

16 advertised

extract — Extract a web page
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Extract content from a web page. Supports HTML and Markdown output formats, optional JavaScript rendering via headless browser, proxy geo-targeting, custom HTTP headers, and explicit browser wait controls via the wait_config object. Can run synchronously (returns content immediately) or asynchronously (returns a job ID that can be polled with the 'job' tool). Use 'render_js=true' for pages that require JavaScript to load their content; supplying wait_config also enables browser rendering automatically. Omit wait_config or set it to null to keep the adaptive browser settle path; send {} or concrete values to opt into explicit mode. Without an API key, extraction is synchronous only, without JavaScript rendering or request headers other than Accept-Language, and limited to a small per-client rate and daily volume. An API key, sent as the X-Api-Key header, lifts these restrictions; the plan's own limits apply instead.

extract input schema
{
  "type": "object",
  "$defs": {
    "ProxyType": {
      "enum": [
        "datacenter",
        "residential",
        "mix"
      ],
      "type": "string",
      "title": "ProxyType"
    },
    "WaitUntil": {
      "enum": [
        "commit",
        "domcontentloaded",
        "load",
        "networkidle"
      ],
      "type": "string",
      "title": "WaitUntil"
    },
    "WaitConfig": {
      "type": "object",
      "title": "WaitConfig",
      "properties": {
        "wait_for": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 4096
            },
            {
              "type": "null"
            }
          ],
          "title": "Wait For",
          "default": null,
          "description": "CSS selector or XPath expression to wait for before extracting the DOM. At least one matching element must become attached to the DOM for the wait to succeed. XPath expressions must start with `//` or `xpath=`; anything else is treated as a CSS selector. Applied after wait_until."
        },
        "wait_until": {
          "anyOf": [
            {
              "$ref": "#/$defs/WaitUntil"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Playwright page lifecycle event to wait for during navigation, before the selector wait or explicit delay. Accepted values: `commit` — response headers received and navigation committed; `domcontentloaded` — HTML parsed and DOM ready (no sub-resources); `load` — page and all sub-resources (images, scripts) fully loaded; `networkidle` — no network activity for 500 ms. When omitted, defaults to `domcontentloaded`."
        },
        "wait_timeout": {
          "anyOf": [
            {
              "type": "integer",
              "maximum": 30000,
              "minimum": 0
            },
            {
              "type": "null"
            }
          ],
          "title": "Wait Timeout",
          "default": null,
          "description": "Deliberate pause in milliseconds inserted after wait_for resolves (or immediately after wait_until when wait_for is omitted), before the DOM is captured. Use to allow late-settling JavaScript to finish rendering. Range: 0–30 000 ms."
        }
      },
      "description": "Explicit browser wait policy applied in order: wait_until → wait_for → wait_timeout.\nWhen a non-null WaitConfig is provided, the adaptive default settle phase is skipped\nand the caller owns the full wait sequence. Null fields inside the object are treated\nthe same as absence of that field."
    },
    "OutputFormat": {
      "enum": [
        "markdown",
        "html"
      ],
      "type": "string",
      "title": "OutputFormat"
    },
    "ProxySettings": {
      "type": "object",
      "title": "ProxySettings",
      "properties": {
        "type": {
          "$ref": "#/$defs/ProxyType",
          "default": "residential",
          "description": "Type of proxy to use (datacenter or residential). Defaults to 'residential' when omitted."
        },
        "country": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Z]{2}$"
            },
            {
              "type": "null"
            }
          ],
          "title": "Country",
          "default": null,
          "description": "ISO 3166-1 alpha-2 country code for geo-targeting (e.g., 'US', 'GB'). Codes that are not backed by a geo-targeted proxy pool are rejected rather than silently ignored. If null, the server auto-resolves a country from the target URL (domain/path overrides first, then the TLD). If no country can be inferred, the upstream proxy provider picks the exit region."
        }
      }
    },
    "ExtractRequest": {
      "type": "object",
      "title": "ExtractRequest",
      "required": [
        "url"
      ],
      "properties": {
        "url": {
          "type": "string",
          "title": "Url",
          "format": "uri",
          "minLength": 1,
          "description": "URL to extract content from"
        },
        "proxy": {
          "anyOf": [
            {
              "$ref": "#/$defs/ProxySettings"
            },
            {
              "type": "null"
            }
          ],
          "default": {
            "type": "residential",
            "country": null
          },
          "description": "Proxy configuration. Optional — when omitted or explicitly `null`, defaults are applied: residential type, country auto-resolved from the target URL (domain/path overrides first, then the TLD; if nothing matches, the upstream proxy provider picks the exit region). Send an object to override either field; individual fields inside the object may also be null (see ProxySettings)."
        },
        "formats": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/OutputFormat"
          },
          "title": "Formats",
          "default": [
            "html"
          ],
          "description": "Output formats to return"
        },
        "headers": {
          "anyOf": [
            {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            },
            {
              "type": "null"
            }
          ],
          "title": "Headers",
          "default": null,
          "description": "Custom HTTP headers to include in extraction request. `Accept-Language` is the one exception on browser-rendered requests: it is not forwarded verbatim, because it would override the header the browser derives from its locale and leave the wire value contradicting `navigator.language`. The language you ask for is still honoured — it selects the browser locale, paired with the proxy country's region, so `en-US` through a German proxy renders the page as `en-DE`. `Host` and `:authority` are dropped: the target host always comes from `url`."
        },
        "timeout": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 1000
            },
            {
              "type": "null"
            }
          ],
          "title": "Timeout",
          "default": null,
          "description": "Milliseconds this request may take, counted from when we receive it and including any queue wait. A wait for the per-site rate limit or for a free thread uses the same time: when it does not fit, the request is refused with 429 instead of being held longer. On expiry the escalation chain stops rather than the response merely arriving sooner: no further browser is launched, and the request is not billed. Omit it to keep the system ceiling. Sync requests only: sending it with processing_mode=async is rejected rather than ignored, because an async caller holds a job id and polls at its own pace. Values above the ceiling are clamped to it."
        },
        "render_js": {
          "type": "boolean",
          "title": "Render Js",
          "default": false,
          "description": "If true, uses a headless browser to render the page (slower, more expensive)."
        },
        "wait_config": {
          "anyOf": [
            {
              "$ref": "#/$defs/WaitConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Grouped browser wait policy. Optional: when omitted or null, browser requests use the adaptive default settle policy whenever a browser runs. Send a non-null object to opt into caller-owned explicit wait mode, which skips the adaptive default settle phase. Null fields inside wait_config behave the same as absence. If render_js is not set explicitly, any non-null wait_config auto-enables browser rendering and the effective render_js value is returned in metadata. If render_js=false is sent together with a non-null wait_config, the request is rejected as ambiguous."
        },
        "processing_mode": {
          "$ref": "#/$defs/ProcessingMode",
          "default": "sync",
          "description": "Processing mode: sync (block until done) or async (starts job and return job ID)"
        }
      }
    },
    "ProcessingMode": {
      "enum": [
        "sync",
        "async"
      ],
      "type": "string",
      "title": "ProcessingMode"
    }
  },
  "title": "extractArguments",
  "required": [
    "extract_request"
  ],
  "properties": {
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "extract_request": {
      "$ref": "#/$defs/ExtractRequest"
    }
  }
}
extract annotations
{
  "title": "Extract a web page",
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}
job — Get an extraction job
Advertised by the server during the last successful anonymous check.
Advertised read-only

Retrieve the result of an asynchronous extraction job by its job ID. Returns the current status (pending, running, completed, or failed) and, once completed, the extracted content and metadata. Use this tool to poll for results after submitting an extraction with processing_mode='async'. Requires a Geonode API key, sent as the X-Api-Key header.

job input schema
{
  "type": "object",
  "title": "get_job_resultArguments",
  "required": [
    "job_id"
  ],
  "properties": {
    "job_id": {
      "type": "string",
      "title": "Job Id"
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    }
  }
}
job annotations
{
  "title": "Get an extraction job",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
jobs — List extraction jobs
Advertised by the server during the last successful anonymous check.
Advertised read-only

List extraction jobs with optional filters. Filter by job ID, URL, status (pending, running, completed, failed), output format, or date range. Results are paginated; use 'page' and 'page_size' to navigate large result sets. Requires a Geonode API key, sent as the X-Api-Key header.

jobs input schema
{
  "type": "object",
  "$defs": {
    "JobStatus": {
      "enum": [
        "queued",
        "processing",
        "completed",
        "failed",
        "cancelled"
      ],
      "type": "string",
      "title": "JobStatus"
    },
    "OutputFormat": {
      "enum": [
        "markdown",
        "html"
      ],
      "type": "string",
      "title": "OutputFormat"
    }
  },
  "title": "list_jobsArguments",
  "properties": {
    "url": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Url",
      "default": null
    },
    "page": {
      "type": "integer",
      "title": "Page",
      "default": 1
    },
    "job_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Job Id",
      "default": null
    },
    "output": {
      "anyOf": [
        {
          "$ref": "#/$defs/OutputFormat"
        },
        {
          "type": "null"
        }
      ],
      "default": null
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "end_date": {
      "anyOf": [
        {
          "type": "string",
          "format": "date-time"
        },
        {
          "type": "null"
        }
      ],
      "title": "End Date",
      "default": null
    },
    "page_size": {
      "type": "integer",
      "title": "Page Size",
      "default": 100
    },
    "job_status": {
      "anyOf": [
        {
          "$ref": "#/$defs/JobStatus"
        },
        {
          "type": "null"
        }
      ],
      "default": null
    },
    "start_date": {
      "anyOf": [
        {
          "type": "string",
          "format": "date-time"
        },
        {
          "type": "null"
        }
      ],
      "title": "Start Date",
      "default": null
    }
  }
}
jobs annotations
{
  "title": "List extraction jobs",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
statistics — Get extraction statistics
Advertised by the server during the last successful anonymous check.
Advertised read-only

Retrieve aggregated extraction statistics for the authenticated user. Returns metrics such as total jobs, success and failure counts, and usage breakdowns over the specified date range: at most 366 days, counted back from the end date (an older start date is moved up; an end date after now is moved back to now). Defaults to the last 30 days when no dates are provided. Requires a Geonode API key, sent as the X-Api-Key header.

statistics input schema
{
  "type": "object",
  "title": "get_statisticsArguments",
  "properties": {
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "end_date": {
      "anyOf": [
        {
          "type": "string",
          "format": "date-time"
        },
        {
          "type": "null"
        }
      ],
      "title": "End Date",
      "default": null
    },
    "start_date": {
      "anyOf": [
        {
          "type": "string",
          "format": "date-time"
        },
        {
          "type": "null"
        }
      ],
      "title": "Start Date",
      "default": null
    }
  }
}
statistics annotations
{
  "title": "Get extraction statistics",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
batch — Start a batch extraction
Advertised by the server during the last successful anonymous check.
Open-world

Start an asynchronous batch extraction job from an explicit list of URLs. Supports HTML and Markdown output formats, optional JavaScript rendering, proxy settings, custom headers, and the grouped wait_config browser wait policy. Omit wait_config or set it to null to keep adaptive browser settling for child extractions; send {} or concrete values to opt every child extraction into explicit mode. Returns a job ID that can be polled with the 'batch_status' tool. Requires a Geonode API key, sent as the X-Api-Key header.

batch input schema
{
  "type": "object",
  "$defs": {
    "ProxyType": {
      "enum": [
        "datacenter",
        "residential",
        "mix"
      ],
      "type": "string",
      "title": "ProxyType"
    },
    "WaitUntil": {
      "enum": [
        "commit",
        "domcontentloaded",
        "load",
        "networkidle"
      ],
      "type": "string",
      "title": "WaitUntil"
    },
    "WaitConfig": {
      "type": "object",
      "title": "WaitConfig",
      "properties": {
        "wait_for": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 4096
            },
            {
              "type": "null"
            }
          ],
          "title": "Wait For",
          "default": null,
          "description": "CSS selector or XPath expression to wait for before extracting the DOM. At least one matching element must become attached to the DOM for the wait to succeed. XPath expressions must start with `//` or `xpath=`; anything else is treated as a CSS selector. Applied after wait_until."
        },
        "wait_until": {
          "anyOf": [
            {
              "$ref": "#/$defs/WaitUntil"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Playwright page lifecycle event to wait for during navigation, before the selector wait or explicit delay. Accepted values: `commit` — response headers received and navigation committed; `domcontentloaded` — HTML parsed and DOM ready (no sub-resources); `load` — page and all sub-resources (images, scripts) fully loaded; `networkidle` — no network activity for 500 ms. When omitted, defaults to `domcontentloaded`."
        },
        "wait_timeout": {
          "anyOf": [
            {
              "type": "integer",
              "maximum": 30000,
              "minimum": 0
            },
            {
              "type": "null"
            }
          ],
          "title": "Wait Timeout",
          "default": null,
          "description": "Deliberate pause in milliseconds inserted after wait_for resolves (or immediately after wait_until when wait_for is omitted), before the DOM is captured. Use to allow late-settling JavaScript to finish rendering. Range: 0–30 000 ms."
        }
      },
      "description": "Explicit browser wait policy applied in order: wait_until → wait_for → wait_timeout.\nWhen a non-null WaitConfig is provided, the adaptive default settle phase is skipped\nand the caller owns the full wait sequence. Null fields inside the object are treated\nthe same as absence of that field."
    },
    "BatchRequest": {
      "type": "object",
      "title": "BatchRequest",
      "required": [
        "urls"
      ],
      "properties": {
        "urls": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "title": "Urls",
          "maxItems": 1000,
          "minItems": 1,
          "description": "URLs to extract in one batch"
        },
        "proxy": {
          "$ref": "#/$defs/ProxySettings",
          "description": "Proxy configuration"
        },
        "formats": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/OutputFormat"
          },
          "title": "Formats",
          "default": [
            "markdown"
          ],
          "description": "Output formats to return"
        },
        "headers": {
          "anyOf": [
            {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            },
            {
              "type": "null"
            }
          ],
          "title": "Headers",
          "default": null,
          "description": "Custom HTTP headers to include in extraction requests. `Host` and `:authority` are dropped: the target host always comes from each item's URL"
        },
        "render_js": {
          "type": "boolean",
          "title": "Render Js",
          "default": false,
          "description": "If true, uses a headless browser to render the page for every batch item"
        },
        "wait_config": {
          "anyOf": [
            {
              "$ref": "#/$defs/WaitConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Grouped browser wait policy applied to every batch item. Optional — when omitted or explicitly `null`, each child extraction uses the adaptive default settle policy whenever a browser runs. Send an object to opt every child extraction into caller-owned explicit wait mode, which skips the adaptive default settle phase. Only non-null wait_config values count as provided; null fields inside wait_config behave the same as absence. If render_js is not set explicitly, any non-null wait_config value auto-enables browser rendering for the workflow and the effective render_js value is returned in batch_config. If you explicitly send render_js=false together with non-null wait_config values, the request is rejected as ambiguous."
        },
        "ignore_invalid_urls": {
          "type": "boolean",
          "title": "Ignore Invalid Urls",
          "default": true,
          "description": "If true, invalid URLs are skipped and returned in invalid_urls instead of failing the request"
        }
      }
    },
    "OutputFormat": {
      "enum": [
        "markdown",
        "html"
      ],
      "type": "string",
      "title": "OutputFormat"
    },
    "ProxySettings": {
      "type": "object",
      "title": "ProxySettings",
      "properties": {
        "type": {
          "$ref": "#/$defs/ProxyType",
          "default": "residential",
          "description": "Type of proxy to use (datacenter or residential). Defaults to 'residential' when omitted."
        },
        "country": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Z]{2}$"
            },
            {
              "type": "null"
            }
          ],
          "title": "Country",
          "default": null,
          "description": "ISO 3166-1 alpha-2 country code for geo-targeting (e.g., 'US', 'GB'). Codes that are not backed by a geo-targeted proxy pool are rejected rather than silently ignored. If null, the server auto-resolves a country from the target URL (domain/path overrides first, then the TLD). If no country can be inferred, the upstream proxy provider picks the exit region."
        }
      }
    }
  },
  "title": "batchArguments",
  "required": [
    "batch_request"
  ],
  "properties": {
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "batch_request": {
      "$ref": "#/$defs/BatchRequest"
    }
  }
}
batch annotations
{
  "title": "Start a batch extraction",
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": false
}
batch_status — Get batch status and results
Advertised by the server during the last successful anonymous check.
Advertised read-only

Retrieve the status and paginated results of a batch extraction job by its job ID. Returns item counts, invalid URLs, and the current page of per-URL extraction results. Requires a Geonode API key, sent as the X-Api-Key header.

batch_status input schema
{
  "type": "object",
  "title": "get_batch_resultArguments",
  "required": [
    "job_id"
  ],
  "properties": {
    "page": {
      "type": "integer",
      "title": "Page",
      "default": 1
    },
    "job_id": {
      "type": "string",
      "title": "Job Id"
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "page_size": {
      "type": "integer",
      "title": "Page Size",
      "default": 10
    }
  }
}
batch_status annotations
{
  "title": "Get batch status and results",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
cancel_batch — Cancel a batch job
Advertised by the server during the last successful anonymous check.
Advertised destructive

Cancel a batch job by its job ID. Stops scheduling new batch items while allowing in-flight child extractions to drain. Requires a Geonode API key, sent as the X-Api-Key header.

cancel_batch input schema
{
  "type": "object",
  "title": "cancel_batchArguments",
  "required": [
    "job_id"
  ],
  "properties": {
    "job_id": {
      "type": "string",
      "title": "Job Id"
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    }
  }
}
cancel_batch annotations
{
  "title": "Cancel a batch job",
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": true
}
crawl — Start a site crawl
Advertised by the server during the last successful anonymous check.
Open-world

Start a website crawl job from a seed URL. Crawls pages breadth-first (BFS) up to the 'depth' parameter (BFS levels from the seed) and the 'limit' parameter (maximum number of pages to crawl). Supports Markdown and HTML output formats, optional JavaScript rendering, proxy geo-targeting, domain filtering, and the grouped wait_config browser wait policy. Omit wait_config or set it to null to keep adaptive browser settling for page extractions; send {} or concrete values to opt every page extraction into explicit mode. Returns a job ID that can be polled with the 'crawl_status' tool. Requires a Geonode API key, sent as the X-Api-Key header.

crawl input schema
{
  "type": "object",
  "$defs": {
    "ProxyType": {
      "enum": [
        "datacenter",
        "residential",
        "mix"
      ],
      "type": "string",
      "title": "ProxyType"
    },
    "WaitUntil": {
      "enum": [
        "commit",
        "domcontentloaded",
        "load",
        "networkidle"
      ],
      "type": "string",
      "title": "WaitUntil"
    },
    "WaitConfig": {
      "type": "object",
      "title": "WaitConfig",
      "properties": {
        "wait_for": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 4096
            },
            {
              "type": "null"
            }
          ],
          "title": "Wait For",
          "default": null,
          "description": "CSS selector or XPath expression to wait for before extracting the DOM. At least one matching element must become attached to the DOM for the wait to succeed. XPath expressions must start with `//` or `xpath=`; anything else is treated as a CSS selector. Applied after wait_until."
        },
        "wait_until": {
          "anyOf": [
            {
              "$ref": "#/$defs/WaitUntil"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Playwright page lifecycle event to wait for during navigation, before the selector wait or explicit delay. Accepted values: `commit` — response headers received and navigation committed; `domcontentloaded` — HTML parsed and DOM ready (no sub-resources); `load` — page and all sub-resources (images, scripts) fully loaded; `networkidle` — no network activity for 500 ms. When omitted, defaults to `domcontentloaded`."
        },
        "wait_timeout": {
          "anyOf": [
            {
              "type": "integer",
              "maximum": 30000,
              "minimum": 0
            },
            {
              "type": "null"
            }
          ],
          "title": "Wait Timeout",
          "default": null,
          "description": "Deliberate pause in milliseconds inserted after wait_for resolves (or immediately after wait_until when wait_for is omitted), before the DOM is captured. Use to allow late-settling JavaScript to finish rendering. Range: 0–30 000 ms."
        }
      },
      "description": "Explicit browser wait policy applied in order: wait_until → wait_for → wait_timeout.\nWhen a non-null WaitConfig is provided, the adaptive default settle phase is skipped\nand the caller owns the full wait sequence. Null fields inside the object are treated\nthe same as absence of that field."
    },
    "CrawlRequest": {
      "type": "object",
      "title": "CrawlRequest",
      "required": [
        "url"
      ],
      "properties": {
        "url": {
          "type": "string",
          "title": "Url",
          "format": "uri",
          "minLength": 1,
          "description": "Seed URL to start crawling from"
        },
        "depth": {
          "type": "integer",
          "title": "Depth",
          "default": 2,
          "maximum": 10,
          "minimum": 1,
          "description": "Maximum BFS depth from the seed URL (1 = seed only)"
        },
        "limit": {
          "type": "integer",
          "title": "Limit",
          "default": 50,
          "maximum": 10000,
          "minimum": 1,
          "description": "Maximum number of pages to crawl"
        },
        "proxy": {
          "anyOf": [
            {
              "$ref": "#/$defs/ProxySettings"
            },
            {
              "type": "null"
            }
          ],
          "default": {
            "type": "residential",
            "country": null
          },
          "description": "Proxy configuration for page requests. Optional — when omitted or explicitly `null`, defaults are applied per page: residential type, country auto-resolved from each page URL (domain/path overrides first, then the TLD; if nothing matches, the upstream proxy provider picks the exit region). Send an object to override either field; individual fields inside the object may also be null (see ProxySettings)."
        },
        "formats": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/OutputFormat"
          },
          "title": "Formats",
          "default": [
            "markdown"
          ],
          "description": "Output formats to extract per page"
        },
        "render_js": {
          "type": "boolean",
          "title": "Render Js",
          "default": false,
          "description": "Use a headless browser to render each page (slower, handles JS-heavy sites)"
        },
        "wait_config": {
          "anyOf": [
            {
              "$ref": "#/$defs/WaitConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Grouped browser wait policy applied to every crawled page extraction. Optional — when omitted or explicitly `null`, each page extraction uses the adaptive default settle policy whenever a browser runs. Send an object to opt every page extraction into caller-owned explicit wait mode, which skips the adaptive default settle phase. Only non-null wait_config values count as provided; null fields inside wait_config behave the same as absence. If render_js is not set explicitly, any non-null wait_config value auto-enables browser rendering for the workflow and the effective render_js value is returned in crawl_config. If you explicitly send render_js=false together with non-null wait_config values, the request is rejected as ambiguous."
        },
        "same_domain_only": {
          "type": "boolean",
          "title": "Same Domain Only",
          "default": true,
          "description": "Only follow links that stay on the same domain as the seed URL"
        },
        "include_subdomains": {
          "type": "boolean",
          "title": "Include Subdomains",
          "default": false,
          "description": "When same_domain_only is true, also include subdomains of the seed domain"
        }
      }
    },
    "OutputFormat": {
      "enum": [
        "markdown",
        "html"
      ],
      "type": "string",
      "title": "OutputFormat"
    },
    "ProxySettings": {
      "type": "object",
      "title": "ProxySettings",
      "properties": {
        "type": {
          "$ref": "#/$defs/ProxyType",
          "default": "residential",
          "description": "Type of proxy to use (datacenter or residential). Defaults to 'residential' when omitted."
        },
        "country": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Z]{2}$"
            },
            {
              "type": "null"
            }
          ],
          "title": "Country",
          "default": null,
          "description": "ISO 3166-1 alpha-2 country code for geo-targeting (e.g., 'US', 'GB'). Codes that are not backed by a geo-targeted proxy pool are rejected rather than silently ignored. If null, the server auto-resolves a country from the target URL (domain/path overrides first, then the TLD). If no country can be inferred, the upstream proxy provider picks the exit region."
        }
      }
    }
  },
  "title": "crawlArguments",
  "required": [
    "crawl_request"
  ],
  "properties": {
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "crawl_request": {
      "$ref": "#/$defs/CrawlRequest"
    }
  }
}
crawl annotations
{
  "title": "Start a site crawl",
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": false
}
crawl_status — Get crawl status and results
Advertised by the server during the last successful anonymous check.
Advertised read-only

Retrieve the status and results of a crawl job by its job ID. Returns the current status (queued, running, completed, or failed), page counts, and once completed, the crawled page results with extracted content. Results are paginated; use 'page' and 'page_size' to navigate. Requires a Geonode API key, sent as the X-Api-Key header.

crawl_status input schema
{
  "type": "object",
  "title": "get_crawl_resultArguments",
  "required": [
    "job_id"
  ],
  "properties": {
    "page": {
      "type": "integer",
      "title": "Page",
      "default": 1
    },
    "job_id": {
      "type": "string",
      "title": "Job Id"
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "page_size": {
      "type": "integer",
      "title": "Page Size",
      "default": 10
    }
  }
}
crawl_status annotations
{
  "title": "Get crawl status and results",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
cancel_crawl — Cancel a crawl job
Advertised by the server during the last successful anonymous check.
Advertised destructive

Cancel a crawl job by its job ID. Stops scheduling new crawl pages while allowing in-flight page work to drain. Requires a Geonode API key, sent as the X-Api-Key header.

cancel_crawl input schema
{
  "type": "object",
  "title": "cancel_crawlArguments",
  "required": [
    "job_id"
  ],
  "properties": {
    "job_id": {
      "type": "string",
      "title": "Job Id"
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    }
  }
}
cancel_crawl annotations
{
  "title": "Cancel a crawl job",
  "readOnlyHint": false,
  "openWorldHint": false,
  "destructiveHint": true
}
map — Map a site's URLs
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Discover all URLs under a base URL by combining sitemap parsing with HTML link extraction from the seed page. By default discovery is scoped to the exact seed host (a leading 'www.' is treated as equivalent) and, when the URL includes a path, to URLs under that path; sibling subdomains and outbound links are excluded. Set include_subdomains=true to widen the scope to the whole registrable domain and probe common subdomains (docs, blog, help, support). The optional 'search' parameter filters the discovered URLs by case-insensitive substring match — it does NOT query a search engine. Runs synchronously and returns the discovered links immediately. Requires a Geonode API key, sent as the X-Api-Key header.

map input schema
{
  "type": "object",
  "$defs": {
    "MapRequest": {
      "type": "object",
      "title": "MapRequest",
      "required": [
        "url"
      ],
      "properties": {
        "url": {
          "type": "string",
          "title": "Url",
          "format": "uri",
          "minLength": 1,
          "description": "Base URL to discover links from. By default discovery is scoped to this exact host (treating a leading 'www.' as equivalent) and, when the URL has a path, to URLs under that path. Set include_subdomains=true to widen the scope."
        },
        "search": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Search",
          "default": null,
          "description": "Case-insensitive substring filter applied to discovered URLs. Does not query a search engine; only narrows results found via sitemap/HTML discovery."
        },
        "include_subdomains": {
          "type": "boolean",
          "title": "Include Subdomains",
          "default": false,
          "description": "When false (default), discovery is scoped to the exact seed host only. When true, the scope widens to the whole registrable domain: sibling subdomains found in the seed's sitemap/HTML are kept, and common subdomains (docs, blog, help, support) are actively probed for their own sitemaps."
        },
        "ignore_query_parameters": {
          "type": "boolean",
          "title": "Ignore Query Parameters",
          "default": true,
          "description": "Strip query parameters when normalizing discovered URLs"
        }
      }
    }
  },
  "title": "map_urlsArguments",
  "required": [
    "map_request"
  ],
  "properties": {
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "map_request": {
      "$ref": "#/$defs/MapRequest"
    }
  }
}
map annotations
{
  "title": "Map a site's URLs",
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}
map_jobs — List map jobs
Advertised by the server during the last successful anonymous check.
Advertised read-only

List map jobs for the authenticated user with optional filters. Filter by base URL (partial match), status (pending, running, completed, failed), or date range. Results are paginated; use 'page' and 'page_size' to navigate. Requires a Geonode API key, sent as the X-Api-Key header.

map_jobs input schema
{
  "type": "object",
  "$defs": {
    "JobStatus": {
      "enum": [
        "queued",
        "processing",
        "completed",
        "failed",
        "cancelled"
      ],
      "type": "string",
      "title": "JobStatus"
    }
  },
  "title": "list_map_jobsArguments",
  "properties": {
    "url": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Url",
      "default": null
    },
    "page": {
      "type": "integer",
      "title": "Page",
      "default": 1
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "end_date": {
      "anyOf": [
        {
          "type": "string",
          "format": "date-time"
        },
        {
          "type": "null"
        }
      ],
      "title": "End Date",
      "default": null
    },
    "page_size": {
      "type": "integer",
      "title": "Page Size",
      "default": 10
    },
    "job_status": {
      "anyOf": [
        {
          "$ref": "#/$defs/JobStatus"
        },
        {
          "type": "null"
        }
      ],
      "default": null
    },
    "start_date": {
      "anyOf": [
        {
          "type": "string",
          "format": "date-time"
        },
        {
          "type": "null"
        }
      ],
      "title": "Start Date",
      "default": null
    }
  }
}
map_jobs annotations
{
  "title": "List map jobs",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
map_job — Get a map job
Advertised by the server during the last successful anonymous check.
Advertised read-only

Retrieve the full details and discovered links for a map job by its job ID. Returns the current status and, once completed, the discovered links and their source. Requires a Geonode API key, sent as the X-Api-Key header.

map_job input schema
{
  "type": "object",
  "title": "get_map_jobArguments",
  "required": [
    "job_id"
  ],
  "properties": {
    "job_id": {
      "type": "string",
      "title": "Job Id"
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    }
  }
}
map_job annotations
{
  "title": "Get a map job",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
search — Search the web
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Run a web search and return ranked results. Supports locale targeting (a language code like 'en', a language-region tag like 'en-US', or 'all'), pagination via 'page', safe-search filtering, and restricting results to a recency window via 'time_range'. By default the service rotates across its engines and falls back on failure; set 'engine' to pin one engine with no fallback. Returns the result list, the engine that served it, query suggestions, and any spelling correction. Requires a Geonode API key, sent as the X-Api-Key header.

search input schema
{
  "type": "object",
  "$defs": {
    "SearchRequest": {
      "type": "object",
      "title": "SearchRequest",
      "required": [
        "query"
      ],
      "properties": {
        "page": {
          "type": "integer",
          "title": "Result page",
          "default": 1,
          "maximum": 9,
          "minimum": 1,
          "examples": [
            1,
            2,
            9
          ],
          "description": "Result page to fetch. Without `engine`, 1 to 9. With `engine` set, the pinned engine's own limit applies instead: brave 9, duckduckgo 5, naver 9."
        },
        "safe": {
          "enum": [
            "off",
            "moderate",
            "strict"
          ],
          "type": "string",
          "title": "Safe-search level",
          "default": "off",
          "examples": [
            "off",
            "moderate",
            "strict"
          ],
          "description": "Safe-search filtering level. Accepted values: \"off\", \"moderate\", or \"strict\"."
        },
        "query": {
          "type": "string",
          "title": "Query",
          "maxLength": 1000,
          "minLength": 1,
          "description": "Search query"
        },
        "engine": {
          "anyOf": [
            {
              "enum": [
                "brave",
                "duckduckgo",
                "naver"
              ],
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Search engine",
          "default": null,
          "examples": [
            "brave",
            "duckduckgo",
            "naver"
          ],
          "description": "Pin the search to one engine, with no fallback to any other. Omit to let the service rotate across its engines and fall back on failure, which is what most callers want. Pinning trades reliability for control: a single engine having a bad moment becomes your error instead of being routed around."
        },
        "locale": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Locale",
          "default": null,
          "description": "Locale tag: a language code ('en'), a language-region tag ('en-US'), or 'all'."
        },
        "time_range": {
          "anyOf": [
            {
              "enum": [
                "day",
                "week",
                "month",
                "year"
              ],
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Time range",
          "default": null,
          "examples": [
            "day",
            "week",
            "month",
            "year"
          ],
          "description": "Restrict results to a recency window. Accepted values: \"day\", \"week\", \"month\", or \"year\"."
        }
      }
    }
  },
  "title": "searchArguments",
  "required": [
    "search_request"
  ],
  "properties": {
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "search_request": {
      "$ref": "#/$defs/SearchRequest"
    }
  }
}
search annotations
{
  "title": "Search the web",
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}
search_jobs — List search jobs
Advertised by the server during the last successful anonymous check.
Advertised read-only

List search jobs for the authenticated user with optional filters. Filter by query (partial match), status (pending, running, completed, failed), or date range. Results are paginated; use 'page' and 'page_size' to navigate. Requires a Geonode API key, sent as the X-Api-Key header.

search_jobs input schema
{
  "type": "object",
  "$defs": {
    "JobStatus": {
      "enum": [
        "queued",
        "processing",
        "completed",
        "failed",
        "cancelled"
      ],
      "type": "string",
      "title": "JobStatus"
    }
  },
  "title": "list_search_jobsArguments",
  "properties": {
    "page": {
      "type": "integer",
      "title": "Page",
      "default": 1
    },
    "query": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Query",
      "default": null
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    },
    "end_date": {
      "anyOf": [
        {
          "type": "string",
          "format": "date-time"
        },
        {
          "type": "null"
        }
      ],
      "title": "End Date",
      "default": null
    },
    "page_size": {
      "type": "integer",
      "title": "Page Size",
      "default": 10
    },
    "job_status": {
      "anyOf": [
        {
          "$ref": "#/$defs/JobStatus"
        },
        {
          "type": "null"
        }
      ],
      "default": null
    },
    "start_date": {
      "anyOf": [
        {
          "type": "string",
          "format": "date-time"
        },
        {
          "type": "null"
        }
      ],
      "title": "Start Date",
      "default": null
    }
  }
}
search_jobs annotations
{
  "title": "List search jobs",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}
search_job — Get a search job
Advertised by the server during the last successful anonymous check.
Advertised read-only

Retrieve the full details and results for a search job by its job ID. Returns the current status and, once completed, the search results, suggestions, and any spelling correction applied. Requires a Geonode API key, sent as the X-Api-Key header.

search_job input schema
{
  "type": "object",
  "title": "get_search_jobArguments",
  "required": [
    "job_id"
  ],
  "properties": {
    "job_id": {
      "type": "string",
      "title": "Job Id"
    },
    "api_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Api Key",
      "default": null
    }
  }
}
search_job annotations
{
  "title": "Get a search job",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}

Prompts

0 advertised

No prompt definitions available.

Resources

0 advertised

No resource definitions available.

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
1448 ms
95th percentile latency
1448 ms

Maintenance history

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

  • · probe · passed · 1448 ms · metadata changed · 16 tool(s), 0 resource(s), 0 resource template(s), 0 prompt(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 geonode-mcp-server https://mcp.geonode.com/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 geonode-mcp-server --url https://mcp.geonode.com/mcp

Cursor

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

Cline

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

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start geonode-mcp-server and inspect its tools.
VS Code configuration
{
  "servers": {
    "geonode-mcp-server": {
      "type": "http",
      "url": "https://mcp.geonode.com/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 geonode-mcp-server https://mcp.geonode.com/mcp

Claude Desktop

Merge this into claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\), then restart Claude Desktop.
Claude Desktop configuration
{
  "mcpServers": {
    "geonode-mcp-server": {
      "url": "https://mcp.geonode.com/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": {
    "geonode-mcp-server": {
      "serverUrl": "https://mcp.geonode.com/mcp"
    }
  }
}

Let your agent find its tools

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

Do you run Geonode MCP Server?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing