Scrapewise

scrapewise_get_scraper_sitemaps

Read-onlyIdempotent

        Returns the URLs that were ingested by a previous
        scrapewise_run_scraper_sitemaps_harvest call, paginated and filterable.
        Each entry is a slim record (URL + image + image title + lastSeen) — not the
        full crawled HTML. Use to inspect what's been harvested or to filter to a
        sub-tree before configuring a Site.

        Args:
          - scraperId (string, path param, required): the scraper's MongoDB ObjectId.
          - pageable (Spring Pageable): page, size, sort.
          - filters (string, query param, optional): URL-encoded JSON Mongo-style
            filter expression on sitemap-entry fields.
          - search (string, query param, optional): keyword that matches anywhere in
            URL / image / imageTitle.
          - restriction (UrlRestriction enum, query param, optional): NONE | BASE_PATH
            | SLASH_COUNT — narrows by URL-shape.

        Returns:
          Spring `Page<SlimSitemapEntryDTO>` — `{content, totalElements, totalPages, ...}`.
          Empty page if no harvest has run, or if the harvest produced 0 URLs.

        Examples:
          - Use when: "show me what sitemap URLs scraper {id} has"
          - Use when: "find sitemap URLs containing 'shoes'" → search=shoes
          - Don't use when: you haven't harvested yet → call
            scrapewise_run_scraper_sitemaps_harvest first

        Error Handling:
          - 401 Unauthorized.
          - 500 INTERNAL.

[runtime hint] This tool returns JSON-as-text — its response shape is dynamic (per-scraper itemsConfig, file binary, etc.) so the MCP outputSchema is omitted. Do not rely on the presence of any specific field in the response; treat the result as a string-or-object blob and parse defensively.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "scraperId": "<scraperId>"
    },
    "name": "scrapewise_get_scraper_sitemaps"
  }
}

Input Schema

Name	Required	Description
`page`	No	Zero-based page index (0..N)
`size`	No	The size of the page to be returned
`sort`	No	Sorting criteria in the format: property,(asc\|desc). Default sort order is ascending. Multiple sort criteria are supported.
`search`	No	Searching by keyword all over URL, image, imageTitle
`filters`	No
`scraperId`	Yes
`restriction`	No	URL restriction mode

Schema Changelog

Changes observed during successful MCP inspections.

First observedNov 9, 2026

TDQS

A4.6/5.0

Behavior4/5

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely new behavior: the slim record shape (URL + image + imageTitle + lastSeen), the empty-page outcome when no harvest has run or zero URLs were produced, and the 401/500 error surface. Slightly short of 5 only because pagination/sort behavior on large result sets is not discussed beyond the shape of the Page wrapper.

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?

Front-loaded with a clear one-sentence summary, then structured Args/Returns/Examples/Error Handling sections that scan quickly. It is a fairly long docstring dump and some entries (pageable, sort) duplicate the schema, but no sentence is filler.

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?

There is no output schema, yet the description supplies the return shape (Spring Page<SlimSitemapEntryDTO> with content/totalElements/totalPages) and the empty-state case, plus a precondition, examples, and error codes. Nothing an agent needs to invoke it correctly is missing.

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 71%, and the Args block fills the main gap: filters is undocumented in the schema and here is explained as a URL-encoded JSON Mongo-style expression over sitemap-entry fields, and restriction's enum is given meaning (narrows by URL-shape) beyond 'URL restriction mode'. page/size/sort only restate what the schema already says, which keeps it below a 5.

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 opening sentence states a specific verb and resource — returns the URLs ingested by a previous harvest call, paginated and filterable — and immediately clarifies what it is not (not the full crawled HTML). It is clearly separable from the harvest sibling and from other scraper getters.

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?

Explicit 'Use when' examples ('show me what sitemap URLs scraper {id} has', search=shoes) and a 'Don't use when' case routing to scrapewise_run_scraper_sitemaps_harvest first. The alternative and the precondition that selects it are stated outright.

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

All Scrapewise tools Inspect

Try in Browser

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Glama MCP Gateway

Add one secure layer between your agents and this server.