Skip to main content
Glama
Krieg2065

Firecrawl MCP Server

by Krieg2065

firecrawl_check_batch_status

Check the status of a batch web scraping job by providing the job ID to monitor progress and completion.

Instructions

Check the status of a batch scraping job.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
idYesBatch job ID to check

Implementation Reference

  • The main handler for the firecrawl_check_batch_status tool. It validates input using isStatusCheckOptions, retrieves the batch operation from the batchOperations map using the provided ID, and returns the current status, progress, any errors, and results if completed.
          case 'firecrawl_check_batch_status': {
            if (!isStatusCheckOptions(args)) {
              throw new Error('Invalid arguments for firecrawl_check_batch_status');
            }
    
            const operation = batchOperations.get(args.id);
            if (!operation) {
              return {
                content: [
                  {
                    type: 'text',
                    text: trimResponseText(
                      `No batch operation found with ID: ${args.id}`
                    ),
                  },
                ],
                isError: true,
              };
            }
    
            const status = `Batch Status:
    Status: ${operation.status}
    Progress: ${operation.progress.completed}/${operation.progress.total}
    ${operation.error ? `Error: ${operation.error}` : ''}
    ${
      operation.result
        ? `Results: ${JSON.stringify(operation.result, null, 2)}`
        : ''
    }`;
    
            return {
              content: [{ type: 'text', text: trimResponseText(status) }],
              isError: false,
            };
          }
  • The Tool object definition including name, description, and inputSchema for validating the required 'id' parameter.
    const CHECK_BATCH_STATUS_TOOL: Tool = {
      name: 'firecrawl_check_batch_status',
      description: 'Check the status of a batch scraping job.',
      inputSchema: {
        type: 'object',
        properties: {
          id: {
            type: 'string',
            description: 'Batch job ID to check',
          },
        },
        required: ['id'],
      },
    };
  • src/index.ts:960-973 (registration)
    Registration of the CHECK_BATCH_STATUS_TOOL in the listTools request handler, making it available to MCP clients.
    server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: [
        SCRAPE_TOOL,
        MAP_TOOL,
        CRAWL_TOOL,
        BATCH_SCRAPE_TOOL,
        CHECK_BATCH_STATUS_TOOL,
        CHECK_CRAWL_STATUS_TOOL,
        SEARCH_TOOL,
        EXTRACT_TOOL,
        DEEP_RESEARCH_TOOL,
        GENERATE_LLMSTXT_TOOL,
      ],
    }));
  • Type guard helper function used in the handler to validate input arguments for the tool.
    function isStatusCheckOptions(args: unknown): args is StatusCheckOptions {
      return (
        typeof args === 'object' &&
        args !== null &&
        'id' in args &&
        typeof (args as { id: unknown }).id === 'string'
      );
  • The Map storing batch operations' status, queried by the handler using the job ID.
    const batchOperations = new Map<string, QueuedBatchOperation>();
Behavior2/5

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the tool checks status but doesn't describe what status values mean (e.g., pending, completed, failed), whether it's idempotent, or any rate limits. For a status-checking tool, this leaves significant gaps in understanding its behavior.

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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple status-checking tool and front-loads the key information.

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

Completeness2/5

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

For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what status information is returned (e.g., progress percentage, error messages), how to interpret results, or dependencies on other tools. This leaves the agent with critical gaps in understanding the tool's full context.

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

Parameters3/5

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

Schema description coverage is 100%, with the single parameter 'id' documented as 'Batch job ID to check'. The description adds no additional meaning beyond this, such as format examples or where to obtain the ID. Given high schema coverage, the baseline score of 3 is appropriate.

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

Purpose4/5

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

The description clearly states the action ('check the status') and resource ('batch scraping job'), making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'firecrawl_check_crawl_status' (which likely checks individual crawl jobs), but the specificity to 'batch' jobs provides some implicit differentiation.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a batch job ID from 'firecrawl_batch_scrape'), exclusions, or comparisons with similar tools like 'firecrawl_check_crawl_status' for non-batch jobs.

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

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Krieg2065/firecrawl-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server