Goose + Scrapeless: Give Block's AI Agent Live Web Data via MCP

TL;DR:

• Goose is Block's open-source AI agent, and it reaches external tools through the Model Context Protocol (MCP). Adding the Scrapeless MCP server gives Goose live web search and scraping it does not have on its own.
• The Scrapeless MCP server ships 21 tools — google_search, google_trends, scrape_html, scrape_markdown, scrape_screenshot, and 16 browser_* actions for driving a cloud browser.
• You add it as one stdio extension, either in Goose's config.yaml or inline with goose run --with-extension, pointing at npx -y scrapeless-mcp-server with your Scrapeless key in the SCRAPELESS_KEY environment variable.
• Goose then calls the tools on its own. Given a task, the agent picks the right Scrapeless tool, runs it, and answers from the returned data — no glue code.
• Start free. New Scrapeless accounts include free credits — sign up at app.scrapeless.com.

Goose, the open-source agent from Block, writes and runs code, drives workflows, and calls external services on its own. What it cannot do out of the box is see the live web — its knowledge stops at the model's training cut-off. Goose closes that gap the same way every MCP host does: by connecting to Model Context Protocol servers that expose tools. This guide connects Goose to the Scrapeless MCP server, so the agent can search Google and scrape pages as part of its reasoning. Every command, tool name, and result below was captured from a live run.

What This Integration Enables

The Scrapeless MCP server is a stdio server: Goose launches it as a subprocess and speaks MCP — a JSON-RPC protocol — over standard input and output. Once connected, Goose gains:

• Live search — google_search and google_trends for real-time results and interest data.
• Page extraction — scrape_html, scrape_markdown, and scrape_screenshot turn any URL into HTML, clean Markdown, or an image.
• Cloud-browser control — 16 browser_* tools (browser_goto, browser_click, browser_type, browser_get_text, browser_snapshot, and more) drive a managed browser for pages that need interaction.

The agent decides which of these to call; you describe the task in plain language.

Prerequisites

• Goose installed (CLI or desktop) — see the Goose project for the installer.
• Node.js with npx available, so Goose can launch the server with npx -y scrapeless-mcp-server.
• A Scrapeless API key — get one on the free plan at app.scrapeless.com.
• A model provider configured in Goose (the agent's reasoning runs on your chosen model).

Add the Scrapeless MCP Server to Goose

There are two ways to register the extension. For a permanent setup, add it to Goose's config.yaml (on Linux, ~/.config/goose/config.yaml), under extensions:

extensions:
  scrapeless:
    name: scrapeless
    type: stdio
    cmd: npx
    args:
      - -y
      - scrapeless-mcp-server@0.4.9
    envs:
      SCRAPELESS_KEY: your-scrapeless-api-key
    enabled: true
    bundled: false
    timeout: 300
    description: Scrapeless web search and scraping tools

On the desktop app, the same values go into Extensions → Add custom extension: name scrapeless, command npx -y scrapeless-mcp-server, and an environment variable SCRAPELESS_KEY.

For a one-off run, skip the config file and pass the extension inline. The --with-extension flag takes a full command with its environment variables:

goose run --with-extension "SCRAPELESS_KEY=your-key npx -y scrapeless-mcp-server@0.4.9" \
  --text "Search Google for 'web scraping' and give me the first result."

What Goose Sees: the Tool List

On connection, Goose performs the MCP handshake and loads the server's tools. The Scrapeless MCP server (protocol 2024-11-05) advertises 21 tools:

google_search      google_trends      scrape_html        scrape_markdown
scrape_screenshot  browser_create     browser_goto       browser_click
browser_type       browser_press_key  browser_get_text   browser_get_html
browser_snapshot   browser_screenshot browser_scroll     browser_scroll_to
browser_go_back    browser_go_forward browser_wait       browser_wait_for
browser_close

The first five return data directly; the browser_* set drives a persistent session on the Scrapeless Scraping Browser — create one, navigate, act, read, and close. For more agent tasks built on these tools, see 5 Scrapeless MCP use cases.

Prompt-Driven Use

With the extension registered, you hand Goose a task and it selects the tool. Asking it to run a search:

goose run --no-session \
  --text "Use the scrapeless google_search tool to search Google for 'web scraping'. Report how many organic results came back and the exact title of the first organic result."

Goose starts a session on your model, calls the tool, and answers from the result. The live run showed the agent invoking the tool and reporting real data:

▸ google_search  (q: web scraping)

The Google search for "web scraping" returned 8 organic results.
The exact title of the first organic result is "Web scraping" from Wikipedia.

The agent chose google_search, passed the query, and read the count and first title back out of the structured response — no parsing code on your side.

Conclusion

Goose is only as capable as the tools it can reach, and the Scrapeless MCP server hands it 21 of them: search, trends, three page-to-data converters, and a full cloud-browser toolset. Register the server as one stdio extension — in config.yaml or inline with --with-extension — set SCRAPELESS_KEY, and Goose calls the right tool for each task and answers from live web data. The whole integration is one extension entry; everything the agent does with it is a prompt.

Ready to give your Goose agent live web data? Start free from the Scrapeless dashboard, read the MCP server documentation, or compare plans on Scrapeless pricing.

FAQ

Q: What is Goose?
A: Goose is an open-source AI agent from Block that runs on the command line and as a desktop app. It executes tasks autonomously and connects to external tools through the Model Context Protocol, so its abilities grow with each MCP server you add.

Q: How does Goose connect to Scrapeless?
A: Goose launches the Scrapeless MCP server as a stdio subprocess (npx -y scrapeless-mcp-server) and speaks MCP over standard input/output. You register it once as an extension in config.yaml or inline with goose run --with-extension.

Q: What tools does the Scrapeless MCP server provide?
A: Twenty-one tools: google_search, google_trends, scrape_html, scrape_markdown, scrape_screenshot, and sixteen browser_* actions for driving a cloud browser (navigate, click, type, read text or HTML, screenshot, scroll, wait, and close).

Q: Where do I put my Scrapeless API key?
A: In the SCRAPELESS_KEY environment variable for the extension — either the envs block in config.yaml or as part of the --with-extension command string. Goose passes it to the server subprocess.

Q: Do I still need a model provider?
A: Yes. Scrapeless provides the tools; Goose's own model provider does the reasoning that decides when to call them. Configure your provider in Goose as usual.

Q: Does the agent call the tools automatically?
A: Yes. Once the extension is registered, you describe the task in plain language and Goose selects the appropriate Scrapeless tool, runs it, and answers from the returned data.

Q: Can Goose interact with pages, not just fetch them?
A: Yes. The browser_* tools drive a persistent cloud-browser session — browser_create, browser_goto, browser_click, browser_type, browser_get_text, and browser_close — so the agent can work through pages that require interaction.