Apify MCP Server: Give Your AI Agent Access to 39,000+ Web Scrapers

Apify’s MCP server at mcp.apify.com exposes over 39,000 web scraping Actors as callable tools that any MCP-compatible AI agent can invoke. Connect once with your Apify API token, and your AI agent gains the ability to scrape Google Maps, Amazon, LinkedIn, TikTok, and hundreds of other sources in real time — no custom APIs, no browser automation boilerplate, no infrastructure to manage. Setup takes under 10 minutes.

---

What is Apify’s MCP Server?

The Model Context Protocol (MCP) is an open standard introduced by Anthropic that lets AI clients call external tools in a structured, interoperable way. Think of it as USB-C for AI tool integration: one spec, any compatible client, any compatible server.

Apify’s MCP implementation wraps its entire Actor marketplace as a tool server. When your agent connects to mcp.apify.com, it receives a catalogue of available tools — each one backed by a production-grade web scraper running on Apify’s cloud infrastructure. Your agent can then call apify/google-maps-scraper or apify/website-content-crawler the same way it would call any other tool: by issuing a structured request, waiting for the result, and incorporating the data into its next reasoning step.

This is a qualitative shift from the usual “give your agent a browser” approach. Instead of spinning up Playwright, fighting anti-bot systems, parsing raw HTML, and managing output storage yourself, you delegate all of that to Apify’s battle-tested infrastructure. The actor handles the scraping; your agent handles the reasoning.

The server is available at https://mcp.apify.com/sse (SSE transport) and supports both the original MCP spec and the newer Streamable HTTP transport introduced in MCP 2025-03-26.

---

Why Does This Matter for AI Developers?

Most AI agents today are knowledge-bound. They know what they were trained on up to a cutoff date, plus whatever context you shove into the prompt. That works for writing, summarizing, and reasoning over supplied documents — but it collapses the moment your agent needs fresh, structured, real-world data.

Consider what a useful research or lead-gen agent actually needs to do:

• Pull current business listings from Google Maps for a specific city and category
• Monitor Amazon prices for a competitor’s product catalog
• Extract contact information from LinkedIn company pages
• Crawl a competitor’s documentation site to summarize recent changes
• Aggregate news and social sentiment around a brand or keyword

Every one of those tasks requires live web data. Before MCP, you would write custom integrations for each data source, maintain them as target sites changed their markup, and bolt them onto your agent with ad-hoc tool definitions. With Apify’s MCP server, all of that collapses into a single configuration step. The full scraper catalogue covers the vast majority of sources any business intelligence or research agent would need.

This is particularly valuable for teams building on top of frontier models. You are not paying for the model’s reasoning ability only to bottleneck it on stale training data. Give it live tools and it becomes genuinely useful for production workflows.

---

Prerequisites

Before you start, you need three things:

1. An Apify account — free tier is sufficient to follow this tutorial. Sign up at apify.com.
2. An Apify API token — generate one in the Apify Console under Settings > Integrations > API tokens. Copy it somewhere safe.
3. An MCP-compatible AI client — Claude Desktop, Cursor, VS Code with the Copilot MCP extension, or any agent framework with MCP support (LangChain, LlamaIndex, AutoGen).

You do not need to install anything locally beyond your chosen AI client. The scraping runs on Apify’s cloud infrastructure.

---

How Do You Connect Apify MCP to Claude Desktop?

Claude Desktop is the most straightforward client for testing MCP integrations because its config format is simple and the tool-calling UI is visual.

Open your Claude Desktop configuration file. On macOS it lives at:

~/Library/Application Support/Claude/claude_desktop_config.json

On Windows:

%APPDATA%\Claude\claude_desktop_config.json

Add the following block inside the mcpServers object (create the file if it does not exist):

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server"
      ],
      "env": {
        "APIFY_TOKEN": "your_apify_api_token_here"
      }
    }
  }
}

Replace your_apify_api_token_here with the token you copied from the Apify Console.

Restart Claude Desktop. You will see a hammer icon in the input area indicating tools are available. Click it to verify the Apify tools appear in the list — you should see entries like apify/google-maps-scraper, apify/website-content-crawler, and dozens of others depending on which Actors are featured at the time.

That is the entire setup. Claude can now call any of those scrapers mid-conversation.

Alternative: remote SSE transport

If you prefer not to install the npm package locally, you can point Claude Desktop directly at the hosted SSE endpoint:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/sse?token=your_apify_api_token_here",
      "transport": "sse"
    }
  }
}

The SSE approach requires no local dependencies but adds a small network hop. For most use cases the difference is negligible.

---

How Do You Connect Apify MCP to Cursor or VS Code Copilot?

Cursor (and VS Code with the GitHub Copilot MCP extension) use a .cursor/mcp.json file at the project root or a global config at ~/.cursor/mcp.json.

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": {
        "APIFY_TOKEN": "your_apify_api_token_here"
      }
    }
  }
}

After saving, open Cursor’s MCP panel (or run the MCP: Reload Servers command in VS Code) and confirm the Apify server shows a green status indicator.

In VS Code with the Copilot Chat MCP extension, add the same block to your user-level settings.json under the "github.copilot.chat.mcp.servers" key. The exact key name may differ across extension versions — check the extension’s README for the current configuration format.

Once connected, you can use Apify tools directly inside Copilot Chat or Cursor’s agent mode. Type @apify or simply ask the agent to “use Apify to scrape…” and the client will route the call through MCP.

---

Example: Ask Claude to Scrape Google Maps Leads

Here is a real walkthrough. With the MCP integration active in Claude Desktop, open a new conversation and type:

“Use Apify to find all Italian restaurants in Austin, Texas with at least 50 reviews. Give me their name, address, phone number, rating, and website URL.”

Claude will reason through the request, select the apify/google-maps-scraper tool, and construct a tool call with inputs like:

{
  "searchStringsArray": ["Italian restaurants in Austin Texas"],
  "maxCrawledPlacesPerSearch": 100,
  "minReviews": 50,
  "includeWebResults": true
}

Within 30-60 seconds, Apify returns a structured dataset. Claude then formats it into a clean table or hands it back as JSON — whichever you asked for.

The Google Maps scraper use case is one of the most common lead-gen patterns we see: pick a city, pick a category, set a minimum review count as a quality filter, and pipe the results directly into a CRM or outreach sequence.

What makes this agent-native rather than just “running a scraper” is that Claude can chain it: extract the restaurants, then use apify/website-content-crawler to visit each website and extract the booking URL or contact email, then format a final enriched table with no additional prompting from you.

---

Example: Monitor Competitor Prices on Amazon

Price monitoring is a natural fit for an agentic workflow because it needs to run on a schedule and produce actionable output.

Set up the Apify MCP connection in a headless agent framework (LangChain or AutoGen work well here) and give the agent a prompt like:

“Check the current price and availability of ASIN B0XXXXXXXXX on Amazon. If the price has dropped more than 10% from the last recorded price of $49.99, send me an email summary.”

The agent calls apify/amazon-product-scraper via MCP, receives the current listing data in structured JSON, compares the price field against your baseline, and conditionally triggers a notification. You can wrap this in a cron job or use Apify’s built-in scheduling to run the underlying actor on a set interval.

This pattern — observe, compare, act — is exactly where agentic scraping earns its keep. A static scraper dumps data into a bucket; an MCP-connected agent makes decisions with that data.

---

What Are Agentic Payments and How Do They Work With Apify?

One emerging challenge with agent-to-agent systems is billing. When your AI agent autonomously triggers 500 Actor runs overnight, who authorized those charges and how does the billing flow?

Apify has been exploring integration with x402 (a micropayment protocol for AI agents) and Skyfire (an agent-native payment network). The idea is that agents carry their own payment credentials — effectively a wallet tied to an API key — and can autonomously authorize spending up to a defined limit per run or per session.

In practice for most developers today: you set an Apify account spending cap, and the API token your agent uses inherits that cap. If the agent burns through your monthly budget, subsequent calls fail gracefully with a quota error. Full autonomous billing is still maturing as a standard, but Apify is positioned early in the ecosystem given its existing API-first architecture.

---

What Are the Best Use Cases for an Apify-Powered AI Agent?

The Apify use cases page catalogs these in detail, but three patterns stand out for AI developers specifically:

Research agent: Connect to apify/google-search-scraper and apify/website-content-crawler. Give the agent a topic, let it run searches, crawl the top results, and synthesize a cited briefing document. This is the pattern that makes RAG pipelines genuinely dynamic instead of relying on a static knowledge base.

Lead generation agent: Chain Google Maps, LinkedIn company scrapers, and a contact enrichment actor. The agent collects raw business listings, filters by your ICP criteria (employee count, industry, geography), and outputs a scored list of prospects. See our guide to web scraping for AI training data for patterns that extend this into data pipeline design.

Competitive intelligence agent: Feed apify/website-content-crawler a list of competitor blog and changelog URLs, run it weekly, and have the agent diff the output against the previous run. New pages get summarized and routed to a Slack channel or Notion database automatically.

All three patterns are described in more depth in our complete web scraping guide for 2026, which also covers proxy rotation, JavaScript rendering, and handling login-gated content.

---

Verdict

Apify’s MCP server is the cleanest solution available today for giving AI agents access to live web data at scale. The integration takes under 10 minutes in any MCP-compatible client, the Actor marketplace covers the sources that actually matter for business use cases, and the pay-per-use pricing model means you are not committing to infrastructure before you have validated your agent’s workflow.

The opinionated recommendation: start with Claude Desktop for prototyping (the visual tool-call UI makes it easy to inspect what inputs the agent is sending), then migrate to a headless agent framework once you have a workflow that produces reliable results. Use Apify’s Actor scheduling for recurring tasks rather than building your own cron infrastructure — it handles retries, storage, and run history out of the box.

If you are building a research, lead-gen, or competitive intelligence agent in 2026, Apify MCP is the tool integration that closes the gap between the model’s reasoning capability and the real-world data it needs to act on.