How to Add Web Scraping to Google Antigravity: Scrapeless MCP Integration Guide

Key Takeaways:

• One config block is the whole integration. Google Antigravity supports the Model Context Protocol. Drop a single scrapeless block into ~/.gemini/antigravity/mcp_config.json and the agent gains a hardened cloud browser, residential proxies in 195+ countries, a Google SERP scraper, a Google Trends scraper, and HTML/Markdown/Screenshot page helpers — all reachable through @-mention or natural-language prompts inside the Antigravity chat panel.
• The agent stops getting blocked. Antigravity ships strong coding tools but does not include a hardened scraping surface out of the box. For sites with meaningful anti-bot protection (Cloudflare Turnstile, Akamai Bot Manager, IP-reputation lists), JavaScript-only SPAs, or geo-bound listings, the cloud browser is what carries the request to a usable response. Routing through Scrapeless Scraping Browser swaps in cloud-side JavaScript rendering, residential-proxy egress, and anti-detection fingerprinting on every session.
• 15+ MCP tools, one namespace. Browser primitives (browser_create, browser_goto, browser_get_html, browser_get_text, browser_click, browser_type, browser_press_key, browser_scroll, browser_screenshot, browser_snapshot, browser_close), one-shot page helpers (scrape_html, scrape_markdown, scrape_screenshot), and Google data tools (google_search, google_trends). The agent's planner composes the ones it needs per turn.
• Stdio is the default; HTTP streamable is the cloud-hosted path. Stdio mode runs npx scrapeless-mcp-server as a child process of Antigravity and is the right default for a developer workstation. HTTP streamable mode points the agent at https://api.scrapeless.com/mcp and is the right default for Antigravity running in a hosted dev container, a remote workspace, or anywhere npx cannot reliably spawn.
• Model-agnostic by design. Antigravity routes prompts through Gemini 3 Pro and Gemini 3 Flash, with Claude Sonnet 4.6, Claude Opus 4.6, and GPT-OSS available as alternative backends through the same agent loop. The Scrapeless MCP integration runs identically across all of them — the protocol is the contract, not the model.
• Coexists with the rest of the Antigravity MCP stack. The scrapeless block sits next to Context-7, Sequential Thinking, BigQuery, AlloyDB, or any other MCP server already wired in. Antigravity's planner routes tools by @-mention or by description matching; tool surfaces don't collide.
• Free to start. New Scrapeless accounts include free Scraping Browser runtime — sign up at app.scrapeless.com. Full pricing is at scrapeless.com/en/pricing.

Introduction: the agent is only as useful as its access to the live web

Google Antigravity shipped in November 2025 as Google's agent-first IDE — a Visual Studio Code fork built around Gemini 3 Pro and Gemini 3 Flash, with Claude Sonnet 4.6, Claude Opus 4.6, and GPT-OSS available as alternative backends. The pitch is straightforward: the developer plays architect, the agent does the construction work. For codegen, refactors, doc lookups, and database introspection that works as advertised — Antigravity's built-in tools cover file edits, terminal commands, the included Workspace MCP servers, and the agent's own planning loop.

The moment the work needs current, public web data, the picture gets thinner. The agent's default web fetch returns the same JavaScript shell that any anonymous HTTP request would, and on commercial sites the rendered DOM lives behind anti-bot challenges, residential-proxy-gated SERPs, and JS-only SPAs that no headless fetch reaches without help. A prompt like "open this competitor pricing page and pull the plan grid" stops being deterministic once the target site sits behind Cloudflare Turnstile.

This post wires the Scrapeless MCP Server into Antigravity through a single config block. After the wire-up, the agent has 15+ MCP tools mapped to a hardened cloud browser, a Google Search scraper, a Google Trends scraper, and one-shot page helpers. The agent picks which tool to call per turn; the cloud browser handles JS rendering, residential-proxy egress, and anti-detection fingerprinting; the IDE keeps owning the codegen, the file tree, and the terminal. For the same Scrapeless surface through other MCP clients — Claude Desktop, Cursor, OpenAI Codex CLI, Gemini CLI, Claude Code, VS Code + GitHub Copilot Chat — see the companion MCP server walkthrough.

What You Can Do With It

• Live API and library research inside the IDE. Ask the agent to fetch the current docs page for a library through scrape_markdown and reason against the rendered text rather than against a training-cutoff memory of the API.
• Competitor pricing snapshots in the workspace. Drop competitor URLs into the agent chat; get back structured pricing rows the agent can paste into a comparison file alongside the code that consumes them.
• Public-dataset ingestion into the project being built. Have the agent walk a directory listing, extract typed records, and write them straight into a JSON fixture, a SQL seed, or a TypeScript type next to the model layer.
• Region-aware SERP and trend signals. Use google_search and google_trends from inside the agent loop to seed feature flags, A/B copy, or content templates with locale-specific evidence.
• Markdown corpora for RAG and project docs. scrape_markdown returns publisher pages as clean markdown the agent can chunk, embed, or store as project-local context.
• Screenshot-driven UX review. scrape_screenshot and browser_screenshot capture rendered pages for visual diff, layout reference, or design inputs the agent can attach to the conversation.
• Multi-step agent runs the IDE can rerun on demand. A google_search → click into top results → extract typed records → write a summary file plan runs end to end inside a single Antigravity agent turn and replays cleanly whenever the prompt is reissued.

At Scrapeless, we only access publicly available data while strictly complying with applicable laws, regulations, and website privacy policies. The content in this post is for demonstration purposes only.

Why Scrapeless MCP Server

Scrapeless MCP Server is the protocol-level surface in front of Scrapeless Scraping Browser — a customizable, anti-detection cloud browser designed for AI agents — plus the Scrapeless data tools (Google Search, Google Trends, page-level scrape helpers). For Google Antigravity specifically, it brings:

• Cloud-side JavaScript rendering. The cloud browser is full Chromium with the page hydrated before extraction, so SPAs, infinite-scroll feeds, and lazy-loaded panels are first-class targets for browser_goto + browser_get_html.
• Residential proxies in 195+ countries. Geo-bound queries return the listings a local user would see. The proxy region is set on the Scrapeless account; per-query region selection is exposed through the scrapeless-scraping-browser CLI for workflows that need it.
• Anti-detection fingerprinting on every session. UA, timezone, language, screen resolution, WebGL, and canvas randomized per session, so long scroll sessions render identically to organic traffic.
• Session persistence. The browser_create task id is reused across subsequent browser_* calls in the same agent turn; cookies, scroll position, and navigation history all live inside one cloud-browser session.
• One MCP namespace. Every operation the agent needs is a single tool call — discoverable from Antigravity's MCP Servers panel, schema-validated by the protocol, and routable through @scrapeless.
• Free runtime on new accounts. Get an API key on the free plan at app.scrapeless.com. The full MCP tool surface is documented at github.com/scrapeless-ai/scrapeless-mcp-server and the platform docs live at docs.scrapeless.com.

Prerequisites

• Google Antigravity installed. Available on macOS, Windows, and Linux with a free tier plus paid Pro and Ultra plans — download from antigravity.google and sign in with a Google account.
• A Scrapeless account and API key — sign up at app.scrapeless.com and copy the key from Settings → API Key Management.
• Node.js 18 or newer on the workstation (Antigravity uses npx to spawn the stdio MCP server).
• Basic familiarity with editing JSON — the Antigravity MCP config is a flat mcpServers object.

Install

The setup is five sub-steps. Stop after step 5 to confirm the wiring; the rest of the post explains how to drive the tools from the chat.

1. Get your Scrapeless API key

Sign up at app.scrapeless.com, open the dashboard, and from Settings → API Key Management create a key. Copy the value — it goes into the MCP config in step 3.

2. Open Antigravity's MCP config

Two equivalent paths:

UI path — open an Agent session in Antigravity, click the … more-options menu at the top of the agent panel, choose MCP Servers, click Manage MCP Servers, then View raw config. Antigravity opens mcp_config.json in the editor pane.

Direct file edit — open mcp_config.json at the user-scoped path:

• macOS: ~/.gemini/antigravity/mcp_config.json
• Linux: ~/.gemini/antigravity/mcp_config.json
• Windows: %USERPROFILE%\.gemini\antigravity\mcp_config.json

Antigravity's MCP config is currently global — the same mcpServers object applies to every workspace. Per-workspace MCP entries are a tracked feature request on the Antigravity developer forum; until that lands, the scrapeless block below ships once and applies everywhere.

3. Add the Scrapeless MCP server (stdio mode)

Paste the scrapeless block under mcpServers and substitute the API key from step 1:

{
  "mcpServers": {
    "scrapeless": {
      "command": "npx",
      "args": ["-y", "scrapeless-mcp-server"],
      "env": {
        "SCRAPELESS_KEY": "YOUR_SCRAPELESS_KEY"
      }
    }
  }
}

Save the file. Back in Antigravity, return to Manage MCP Servers and click the refresh control — the scrapeless entry should appear with its tool list (browser_*, google_search, google_trends, scrape_html, scrape_markdown, scrape_screenshot) populated. On first run, npx -y scrapeless-mcp-server downloads the package; subsequent restarts reuse the cached version.

If Antigravity already manages other MCP servers, append the scrapeless entry to the existing mcpServers object — do not overwrite the file. The order does not matter; the planner discovers tools by description, not by position.

4. Or use HTTP streamable mode (remote or container-bound agents)

For Antigravity running in a hosted dev container, a remote workspace, a CI sandbox, or anywhere npx cannot reliably keep a long-lived child process alive, swap the stdio block for the HTTP streamable endpoint:

{
  "mcpServers": {
    "scrapeless": {
      "type": "streamable-http",
      "url": "https://api.scrapeless.com/mcp",
      "headers": {
        "x-api-token": "YOUR_SCRAPELESS_KEY"
      }
    }
  }
}

The same YOUR_SCRAPELESS_KEY works in both modes. HTTP streamable is the right default when the host is bound by sandbox rules; stdio is the right default everywhere else.

5. Verify the connection

In a fresh Antigravity agent session, type:

"@scrapeless open https://example.com and tell me the page title."

The agent should call browser_create, then browser_goto, then browser_get_text (or browser_get_html), and reply with "Example Domain". If that returns clean, the MCP server is wired, the API key is valid, and the cloud browser is reachable.

If it does not, the common first-run failures and fixes are:

How you actually use this: prompt your Antigravity agent

After install, the agent owns the discover → extract loop. The MCP server hands Antigravity a typed tool list; the agent reads the tool descriptions and composes calls turn by turn based on the prompt. There is no tools.json to author and no manual MCP call to issue from the IDE side.

Two ways to scope a request to Scrapeless:

• @-mention the server. @scrapeless … tells Antigravity's planner to bias toward Scrapeless tools for that turn. Useful when multiple MCP servers expose overlapping capabilities (e.g. several servers offer a fetch-style tool).
• Name the tool implicitly. Phrases like "search Google for…", "render the page at…", or "scrape that URL as markdown" route to google_search, browser_*, and scrape_markdown once the server is connected, without needing an @-mention.

Prompts you can paste

Worked example: pricing-page extraction inside Antigravity

You type:

"@scrapeless open https://example-saas.com/pricing, scroll the plan grid to the bottom, and return name, price, and feature bullets per plan as JSON. Save the result to pricing.json in the open workspace."

The agent's plan (in plain English):

1. Call browser_create to mint a cloud-browser session.
2. Call browser_goto with the pricing URL.
3. Call browser_wait_for against the plan-card landmark so extraction runs against the hydrated DOM rather than the SPA shell.
4. Call browser_scroll to surface any below-the-fold tiers, then browser_get_html.
5. Parse the plan cards into a JSON array; treat any field absent on a card as null rather than failing the extraction.
6. Call browser_close with the sessionId returned by browser_create.
7. Write the array to pricing.json using Antigravity's built-in file tool.

What you get back (illustrative shape):

[
  {
    "name": "Starter",
    "price": "$0 / month",
    "features": ["1 seat", "1,000 events/mo", "Community support"]
  },
  {
    "name": "Pro",
    "price": "$29 / month",
    "features": ["10 seats", "100K events/mo", "Email support", "Custom domains"]
  },
  {
    "name": "Business",
    "price": "Contact sales",
    "features": ["Unlimited seats", "Custom event volume", "SLA", "SSO/SAML"]
  }
]
// Schema reflects what the agent emits when prompted to extract a pricing grid.
// Field values are illustrative samples.

Antigravity drops pricing.json into the workspace tree and surfaces a per-step trace in the conversation so each MCP tool call is auditable.

Shaping prompts: control what comes back

Get your API key on the free plan: app.scrapeless.com

The Scrapeless MCP tool surface

The full tool list Antigravity discovers when the scrapeless server connects:

browser_* tools share state via the sessionId returned by browser_create. scrape_* and the Google tools are stateless and route through the Scrapeless API directly without minting a session. Tool arguments use camelCase across the surface (sessionId, proxyCountry).

Five workflows that pay for the integration

Each block below is one prompt-driven workflow inside Antigravity. The agent picks tools per turn; the MCP server does the rendering, proxying, and SERP work.

1. Live SERP and trend signals for feature work

A feature flag's copy often depends on what users are currently searching for. Ask the agent to call google_trends for the topic in the target region, then google_search for the head terms, then write the result into a fixture file the running app consumes. The whole loop runs inside one Antigravity turn and refreshes whenever the prompt is reissued.

2. Competitor pricing tracker in a comparison file

Drop a list of competitor pricing URLs into the chat and ask the agent to extract plan name, price, and bullet features per page, dedupe by plan, and write the merged table to competitors.md in the workspace. Subsequent runs diff against the previous snapshot and only update the rows that changed.

3. Public-directory lead lists into the project

For lead-generation prototypes, the agent walks a public directory (a list of software vendors, local businesses, or licensed professionals), calls browser_goto per detail page, extracts contact rows, and writes the records as a seed.sql or leads.json next to the model layer. Residential-proxy egress and JS rendering happen at the cloud-browser layer.

4. RAG corpus from publisher pages

For an embedding pipeline being built inside Antigravity, the agent walks a seed URL list, calls scrape_markdown per page, splits the markdown into chunks, and writes each chunk + URL pair to corpus.jsonl. Because the markdown is already clean, chunk boundaries land on headings and paragraphs rather than mid-tag.

5. Visual regression assets

For a UI refactor, ask the agent to take a full-page scrape_screenshot of staging and production for every page in routes.ts, then diff the pairs. The screenshots come back as files in the workspace; the diff lives in the conversation.

What to know before going to production

• Stdout discipline matters. The stdio MCP transport uses stdout for JSON-RPC. A server that writes non-JSON text to stdout breaks the handshake. The current scrapeless-mcp-server build writes logs to stderr; if a custom fork is in use, audit the log destination.
• Per-call region control is not on the MCP surface. The cloud browser routes through the Scrapeless account's configured region. Workflows that need per-query region pinning (US results vs DE vs JP) call the scrapeless-scraping-browser CLI with --proxy-country or keep multiple API keys for different default regions.
• Per-workspace MCP config is not yet supported in Antigravity. The mcpServers config at ~/.gemini/antigravity/mcp_config.json is global. Project-scoped MCP entries are a tracked feature request on the Antigravity developer forum; until then, the same scrapeless block applies across every workspace.
• Concurrency. Keep ≤ 3 concurrent sessions per host for stable runs. For batch jobs that need higher fan-out, drive the CLI from a worker pool instead of issuing MCP calls in parallel from a single agent.
• MCP response shape. Tool responses come back as content[0].text (plain text). The text-returning stateless data tools (google_search, google_trends, scrape_html, scrape_markdown) prefix their payload with Response:\n\n before the body; Antigravity's planner handles the prefix automatically, but custom scripts parsing the raw response need to strip it. scrape_screenshot returns image binary directly. The browser_* tools return their text payloads without the prefix.

Conclusion: scale your Antigravity agent's reach across the public web

Wiring Scrapeless MCP Server into Antigravity collapses to one JSON block at ~/.gemini/antigravity/mcp_config.json and a refresh of the MCP panel. After that, the agent has a hardened cloud browser, residential-proxy egress, a Google SERP scraper, a Trends scraper, and one-shot HTML/Markdown/Screenshot helpers — all reachable through @-mention or natural-language prompts. The IDE keeps owning the codegen, the file tree, and the terminal; the cloud browser keeps the agent on real, rendered pages.

For the same Scrapeless surface through other MCP clients — Claude Desktop, Cursor, OpenAI Codex CLI, Gemini CLI, Claude Code, VS Code + GitHub Copilot Chat — see the MCP server walkthrough for Google Maps. For agent surfaces that prefer the raw CDP path over MCP, see the Hermes integration post. Antigravity ships a free tier alongside paid Pro and Ultra plans; Scrapeless includes free Scraping Browser runtime on new accounts, with the upgrade paths at scrapeless.com/en/pricing. The pattern stays consistent across every agent surface: pin the right transport for the host, snapshot or render before extracting, persist the session across multi-step turns, and treat absent fields as nullable.

Ready to Build Your AI-Powered Data Pipeline?

Join our community to claim a free plan and connect with developers building Antigravity-driven data pipelines on Scrapeless: Discord · Telegram.

Sign up at app.scrapeless.com for free Scraping Browser runtime, and adapt the patterns above to the workspaces, regions, and pages your Antigravity agent needs.

FAQ

Q1: Which Antigravity version supports MCP?
MCP support shipped with the public preview at launch in November 2025. Any current Antigravity build on macOS, Windows, or Linux exposes the MCP Servers entry in the agent panel's … menu and reads mcp_config.json from ~/.gemini/antigravity/.

Q2: Is scraping with Antigravity + Scrapeless legal?
Scraping publicly visible data is broadly permitted in most jurisdictions, but rules vary by country and by site terms of service. Review the target site's ToS, respect robots.txt where applicable, do not collect personal data without a lawful basis, and consult counsel for commercial-scale pipelines.

Q3: Do I need a residential proxy?
Yes for any site with meaningful anti-bot protection — most retailers, marketplaces, SERPs, and large SaaS landing pages. The Scrapeless MCP server routes every browser_* and scrape_* call through the residential pool by default; no separate proxy configuration is needed for the call to work.

Q4: Can I pick a residential-proxy region per request from the MCP surface?
Not from the MCP browser_create tool — the cloud-browser session uses the proxy region configured on the Scrapeless account. For per-query region selection (US vs DE vs JP), drive the cloud browser through the scrapeless-scraping-browser CLI with --proxy-country, or maintain multiple API keys for different default regions.

Q5: stdio mode vs HTTP streamable mode — which one belongs in Antigravity?
Stdio is the default for a developer workstation: Antigravity spawns npx scrapeless-mcp-server as a child process and talks JSON-RPC over its stdin/stdout. HTTP streamable is the right default when Antigravity runs in a hosted environment (Codespaces, a remote dev container, a CI runner) where the host cannot keep a long-lived child process alive. Both modes use the same API key.

Q6: Where do I add the config — per-workspace or global?
Antigravity's MCP config is currently global; the same mcpServers object at ~/.gemini/antigravity/mcp_config.json applies to every workspace. Per-workspace MCP config is a tracked feature request on the Antigravity developer forum.

Q7: How do I keep the API key out of the JSON file?
Use a placeholder in the JSON and inject the value through an OS environment variable. Set SCRAPELESS_KEY in the shell that launches Antigravity (export SCRAPELESS_KEY=... on macOS/Linux or [Environment]::SetEnvironmentVariable("SCRAPELESS_KEY", "...", "User") on Windows PowerShell), then reference ${SCRAPELESS_KEY} in the env block of the config. Restart Antigravity so the new variable propagates.

Q8: The first browser_create call returns os error 10054 or 503. What now?
Both are transient session-spin-up errors on the Scrapeless residential-proxy pool. A single retry usually succeeds — ask the agent to call browser_close (if a session was minted) and browser_create again, or wrap the call in a 2–3 attempt retry loop.

Q9: How does Antigravity decide which Scrapeless tool to call?
Each MCP tool ships a name and a schema; Antigravity's planner reads the descriptions and matches them to the prompt. @-mentioning the server (@scrapeless …) biases the planner toward the Scrapeless surface for that turn, which is the cleanest way to scope a request when several MCP servers expose overlapping capabilities (e.g. another server also offers a fetch-style tool).

Q10: Can I run this without Antigravity?
Yes. The Scrapeless MCP Server is a standard MCP server, callable from Claude Desktop, Claude Code, Cursor, OpenAI Codex CLI, Gemini CLI, VS Code + GitHub Copilot Chat, or any custom client built against the MCP TypeScript SDK. The same mcpServers JSON snippet drops into each. For non-MCP surfaces, the cloud browser is also reachable through the scrapeless-scraping-browser CLI and the WSS endpoint at wss://browser.scrapeless.com/browser.

Q11: How many concurrent MCP workers per host?
Three concurrent renders per host is the documented ceiling for stable runs. For higher fan-out, run multiple MCP clients (or worker processes hitting the streamable-HTTP endpoint) or, for pure-throughput batch jobs, drive the CLI directly with a parallel worker pool.