Skip to main content
Glama

scrapewise_create_file_scraper

        Creates an uploaded-file scraper in a group from ONE file and starts importing it: every row of
        the file becomes a row of the group's data, exactly like a scraper's run (data view, export,
        merge and matching all work on it). Formats: csv (comma or semicolon separated), jsonl (JSON
        Lines: one JSON object per line) and xlsx (Excel, first sheet only). All values are stored as
        text (an EAN keeps its leading zeros). Uploading is free.

        Small files (about 1 MB of content at most per call): send the whole file in `content` — csv and
        jsonl as the text itself, xlsx as standard base64. Bigger files (CSV or JSON Lines up to the
        server limit, 200 MB by default; Excel up to 36 MB): call this tool WITHOUT `content`. Nothing
        is created then; the answer is `upload` — the ONE HTTP request that sends the file directly
        (a ready `curl -X POST -T` command, and `curl.exe` for Windows, with a <YOUR_API_KEY>
        placeholder and an empty `Expect:` header, so a file over the limit usually answers 413 with a
        clear message). An agent with a shell runs that one command with the customer's API key and
        file; otherwise ask the user to upload the file in the portal (group menu → Upload). Never
        split a file into parts. For Excel files over 36 MB, save them as CSV. CSV or JSON Lines are
        preferred for big files.

        The import runs in the background: follow the import with `scrapewise_get_scraper_load_history`
        (the import job `jobId` is one of its rows) until it is COMPLETED, then read the rows with the
        data tools. An import is all-or-nothing: a stopped
        or failed import keeps no rows.

        Args:
          - groupId (string, path, required): the group (folder) — from scrapewise_get_scraper_group_list.
          - body.name (string, required, 1-200 characters): the scraper's name. Must be new in this
            group. When retrying a failed call, send the exact same name.
          - body.format (string, required): csv, jsonl or xlsx.
          - body.content (string, optional): the file content (see above). Leave it out for a big file.

        Returns:
          FileScraperResultDTO: scraper (the new uploaded-file scraper) + jobId (201). Without content:
          upload {method, url, headers, curl, curlWindows, note} (200) and nothing else.

        Examples:
          - Use when: "add this price list CSV to group X" → name + format=csv + content
          - Use when: "import our 150 MB product feed" → name + format, no content → run the command
          - Don't use when: you have web addresses to scrape → use scrapewise_run_scraper_url_list
          - Don't use when: the uploaded-file scraper already exists and you have a new version of the
            file → use scrapewise_update_file_scraper_file with its scraperId

        Error Handling:
          - 400 BAD_FORMAT: format is not csv/jsonl/xlsx, the content is not valid base64 (xlsx), or
            the Content-Type does not match the format.
          - 400 BAD_NAME: the name is empty or longer than 200 characters.
          - 404 GROUP_NOT_FOUND: the group is not in this account.
          - 409 NAME_TAKEN: a scraper with this name already exists in the group — the body carries its
            scraperId and scraperType. If it is FILE, send the new file to it with
            scrapewise_update_file_scraper_file; otherwise pick another name.
          - 413 FILE_TOO_LARGE / PAYLOAD_TOO_LARGE: the file (or this call's body) is too large — call
            without content for the one-request upload, or save Excel as CSV.
          - 415: a raw upload with another Content-Type than text/csv, application/x-ndjson or the
            xlsx type.
          - 429 INGEST_CAPACITY*: too many uploads at once — retry after Retry-After.
          - 503 STORAGE_UNAVAILABLE: not enough storage right now — try again shortly.
          - 401 Unauthorized; 403 for a read-only API key.

[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": {
      "groupId": "<groupId>",
      "body": "<body>"
    },
    "name": "scrapewise_create_file_scraper"
  }
}

Input Schema

NameRequiredDescriptionDefault
bodyYesObject with the fields name, format, content.
groupIdYesthe group (folder) — from scrapewise_get_scraper_group_list.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed2 schema fields changed
    • addedInput schema / properties / body / description
      Added value: +"Object with the fields name, format, content."
    • addedInput schema / properties / groupId / description
      Added value: +"the group (folder) — from scrapewise_get_scraper_group_list."
  2. Added

TDQS

A4.8/5.0
Behavior5/5

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

Goes well beyond the annotations: uploads are free, import runs in the background, an import is all-or-nothing (a failed or stopped import keeps no rows), size ceilings per format, capacity/rate-limit and storage failure modes, and a worked HTTP 413 fallback. This is consistent with readOnlyHint=false and non-idempotent behavior, since retries hit 409 NAME_TAKEN and the description tells the agent to resend the same name.

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 core action and scope are front-loaded in the first sentence, and the longer blocks are organized under size tiers, Args, Returns, Examples, and Error Handling. It is on the verbose side, with some repetition between the prose, the Args list, and the schema descriptions (format definitions appear twice), but nearly every sentence carries distinct operational information.

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?

The tool has a nested body object, a dual-mode response (201 FileScraperResultDTO vs. 200 upload descriptor), and no output schema; the definition documents both return shapes and the follow-up tools needed to reach completed data. An agent can execute the inline path, the shell-upload path, and the user-portal fallback without further information.

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 already 100%, so most parameter documentation is duplicated. The description nonetheless adds operational meaning the schema can't: the ~1 MB inline limit, when leaving `content` out is required rather than optional, and the retry-name convention tied to 409 NAME_TAKEN. Modest added value over a fully documented schema earns a 4 rather than 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?

States a specific verb and resource ("Creates an uploaded-file scraper in a group from ONE file and starts importing it") and immediately explains the resulting semantics (rows become group data, usable by data view, export, merge, matching). The "ONE file" emphasis and the explicit exclusions of URL scraping and file-version updates let an agent distinguish it from every nearby sibling without opening a schema.

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?

Gives explicit when/when-not routing: web addresses go to scrapewise_run_scraper_url_list, an existing file scraper's new version goes to scrapewise_update_file_scraper_file. It also splits usage by size (inline content vs. no-content upload request), tells the agent to follow the job with scrapewise_get_scraper_load_history until COMPLETED, and cautions never to split files.

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

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.