# MCP Scraper: Full Content
Web intelligence, shared memory, connected accounts, and scheduled cloud-agent work for the AI tools people already use.
## What MCP Scraper is
MCP Scraper gives AI agents a shared web-data, memory, integrations, and scheduling layer. It can collect public evidence, keep approved information searchable across tools, connect authorized business accounts, and run bounded recurring work in the cloud.
Sources:
## Agent surfaces
The product is available through a hosted MCP endpoint, an npm stdio server, a Claude Desktop extension, and a REST API. The same account can be used from Claude, ChatGPT, Cursor, and other compatible agent surfaces.
Sources: ,
## Operating boundary
Public-web collection, private memory, connected-account access, and scheduled actions remain distinct permission lanes. Connected writes require explicit enablement and grants; retrieval results preserve canonical sources and corpus receipts.
Sources: , ,
---
## MCP Scraper — One brain for every AI you use
Canonical URL: https://mcpscraper.dev/
Get any data, give every AI a shared memory, and schedule work in the cloud. One account connects Claude, ChatGPT, Cursor, and the rest of your AI stack.
Scraper · Memory · Scheduler
# Give every AI the same brain.
Get any data, remember what matters, and schedule the next action. One account makes that context available to every AI you already use.
Start for $1 See how Memory works 339 Tools Scrape + Memory + Scheduler 15 Connections 30-Second Set-Up Process One context, carried forward
## Stop rebuilding context in every chat.
Your AI tools do not talk to one another. MCP Scraper gives them a shared way to collect evidence, recall decisions, and continue the work.
01
### Research once, use it everywhere
Scrape Google, Maps, Reddit, YouTube, ad libraries, or any public page straight into memory. Every AI you use can cite it from then on.
What does Reddit say about my brand? 02
### Start with what you already know
Have every assistant check your memory before it acts—past decisions, client preferences, research, and skills. You stop repeating yourself. It stops guessing.
Check memory before you answer 03
### Keep the playbooks that work
Save prompts, processes, and SOPs as living notes. Your whole team’s AIs can pull the same approved way of working.
Share this playbook with the team 04
### Bring the team into one context
Shared vaults, channels, and per-person scoping keep every AI, device, and teammate working from the same brain.
Invite Sarah to the Projects vault 05
### Keep working while you sleep
Put research, rank tracking, monitoring, and connected-account work on a schedule. Cloud agents run the job and file what changed.
Track my rankings every Monday 06
### Build your product on the same tools
Use the same 339 tools behind your own product through MCP, SDKs, the CLI, cURL, or REST—data, memory, and scheduling as your backend.
POST /harvest/sync Start anywhere
## Choose the part you need today.
Scraper and Memory stand on their own. Together, they become the data and context layer behind every AI you use.
Data
### MCP Scraper
174 scraper, connection, and automation tools for Google, Maps, connected services, social media, and a live browser that gets past CAPTCHAs and logins.
Explore Scraper Memory
### MCP Memory
101 tools to remember, organize, share, and recall everything your AI touches—with plain Markdown you can inspect whenever you want.
Explore Memory Application
### Thorbit
Run your SEO workflow—from research and strategy through writing and publishing—in one conversation built on your own data.
Explore Thorbit One account Plain Markdown memory Usage-based Credits Human takeover built in Start with the full brain
## Give your AI a place to continue.
One install connects every supported AI client to the same 339 tools.
Start for $1
---
## What You Can Actually Do With MCP Scraper
Canonical URL: https://mcpscraper.dev/aug-webinar
A live, practical MCP Scraper workshop covering web research, Memory, connected accounts, Scheduled Actions, reusable skills, and real workflows.
---
## MCP Scraper Blog
Canonical URL: https://mcpscraper.dev/blog/
Field guides on AI development, SEO, and developer tools. Every post answers 20–50 real search questions with sourced, practitioner-grade answers.
Field guide · Developer Tools
## Claude Code Evaluated.
Every article about Claude Code tells you it's an AI coding agent you just need to learn to use. This one tells you how to evaluate whether it's worth adopting — with the cost math, the head-to-head comparisons, and the trust answers that every tutorial skips.
May 23, 2026
·
18 min read
·
45 questions answered
Field guide · AI Development
## Vibe Coding.
Andrej Karpathy coined "vibe coding" on February 2, 2025. By November it was Collins Word of the Year. Most of what you'll read about it sells a tool. This is the version that tells you what works, what breaks, what it pays, and what you still have to build yourself after the prototype runs.
May 23, 2026
·
14 min read
·
30 questions answered
Field guide · SEO
## People Also Ask SEO.
PAA strategy ends where programmatic begins. Every competitor guide shows you how to expand boxes — none shows you how to harvest them at scale via API and pipe the data directly into your content system.
May 23, 2026
·
12 min read
·
31 questions answered
Field guide · AI Development
## What Is an MCP?
Every article about what is an MCP tells you it's a universal plug-and-play connector for AI. This one tells you which platforms actually adopted it, when to skip it entirely, and why the USB-C analogy hides the decision your architecture actually requires.
May 23, 2026
·
11 min read
·
30 questions answered
Field guide · MCP Protocol
## When Not to Use an MCP.
The complexity calculus is the wrong frame. In 2026, the real question is whether MCP will still be the dominant protocol when your integration ships — and that requires reading the ecosystem, not the docs.
May 23, 2026
·
15 min read
·
36 questions answered
Field guide · AI Workflows
## AI Development Workflows.
What they are, how they're built, which tools actually matter, and the mistakes most teams make before they figure it out.
May 22, 2026
·
12 min read
·
49 questions answered
Field guide · AI Accuracy
## Who Hallucinates More: ChatGPT or Claude?
Five benchmarks give five different winners — and every "Claude wins" article was benchmarked on a model that is no longer the default. Here is what the current data actually says, and what to do with it.
May 22, 2026
·
14 min read
·
32 questions answered
---
## AI Development Workflows: A Complete Guide
Canonical URL: https://mcpscraper.dev/blog/ai-development-workflows/
Published: 2026-05-23T00:00:00.000Z
Modified: 2026-05-23T00:00:00.000Z
What they are, how they
01
## What is an AI Workflow?
The definition most people skip, and why skipping it costs them three months of rework.
Quick take
### An AI workflow is not an AI tool.
A tool does one thing. A workflow connects data, model, and action into a loop that runs without you. Most teams build tools. Winners build workflows.
An AI workflow is a connected sequence where an AI model handles one or more steps in a larger process. A concrete example: a model reads an incoming invoice, extracts line items, cross-references them against a purchase order in your database, flags discrepancies, and routes it to the right approver — all automatically. The human only touches the exceptions. That's the leverage. Single-step automations (just a prompt, just a classification) are AI tools. Workflows string those steps together with state and decision logic.
The core components of any AI workflow are: agents that perform tasks or make decisions, data pipelines that feed those agents, tool integrations that let agents take action in external systems, and feedback loops that improve outputs over time. Strip away any one of those and you have a prototype, not a workflow. The feedback loop is where most teams cut corners — and it's the one that compounds.
The four stages are: (1) Data input — structured or unstructured data enters the system. (2) Processing and analysis — the model interprets, classifies, or extracts. (3) Decision-making — based on the model's output, the workflow branches. (4) Output with feedback — an action is taken and the result is logged so future runs improve. Most implementations nail stages 1–3 and forget 4. That's why they plateau.
Sequential — tasks run in a fixed order. Good for predictable processes. Parallel — multiple tasks run simultaneously. Good for speed. State machine — waits for an event to transition. Good for long-running or human-in-the-loop processes. Rules-driven — conditional logic branches based on data values. Good for compliance or tiered routing. Most real AI workflows combine two or three of these.
The AI Project Cycle runs: problem definition → data collection → model selection → evaluation → deployment → monitoring . Deployment and monitoring take longer than most teams budget — usually 60% of total project time. Skipping proper problem definition is where 85% of AI projects fail before they start.
02
## Stages of Development.
How AI systems mature from prototype to production — and the adoption curve most organizations get stuck on.
Five stages: Aware (experimenting with prompts), Active (running pilots), Operational (AI is a production dependency), Systemic (AI shapes how teams are structured), and Transformational (the business model itself changes). Most teams stall at Operational — they have working AI but it hasn't changed how decisions get made.
Infrastructure → Data → Model development and operations → Application → Cross-layer governance. The cross-layer governance piece is the one that gets ignored until there's an incident. When you have AI making decisions in production, you need an audit trail, rollback capability, and ownership assignments at every layer — before something goes wrong, not after.
Creation → Initiation → Execution → Review → Approval → Documentation → Archival → Iteration. The Iteration stage is where AI adds disproportionate value — a workflow that can learn from its own execution history will outperform a static one within weeks.
Reactive (no memory), Limited memory (uses recent context — most modern LLMs), Theory of mind (not yet achieved), Self-aware (theoretical). Every AI in production today is limited memory. The "agentic AI" hype is largely about making limited-memory systems behave more like theory-of-mind ones through tool use and persistent context.
Across frameworks, the consistent pillars are: Data (quality and volume), Compute (infrastructure and cost), Algorithms (model architecture), and People (domain expertise to supervise and improve the system). Of these, People is the longest-lead bottleneck. You can rent compute and buy data. You can't rapidly acquire practitioners who know both the domain and the models.
03
## Tools & Platforms.
The honest rundown on what's actually useful versus what's just well-funded.
It depends on where you sit on the complexity curve. No-code : Zapier AI, Make, monday.com. Low-code : n8n, Pipedream. Code-first : LangChain, LlamaIndex, custom Claude/GPT API integrations. No-code gets you to 80% quickly and hits a wall. Code-first has no ceiling but requires engineering time. Most production teams end up hybrid.
Yes — ChatGPT can design, describe, and write the code for workflows. It can also be a step inside a workflow via the API. The distinction matters: using ChatGPT to build a workflow is a productivity tool. Using the API as a node in a running workflow is an architectural decision. The latter is where teams underestimate latency and cost at scale.
ChatGPT remains the most widely recognized AI tool. But popularity in a consumer context doesn't translate to best-in-class for workflows. Claude 3.5 Sonnet is widely considered superior for nuanced writing, coding, and reasoning tasks as of mid-2026. Gemini leads on multimodal and Google Workspace integration. Match the model to the task, not the brand recognition.
For an AI agent architecture: goal definition, perception/input, memory, reasoning/planning, tool use, action execution, and output/feedback . This maps directly to workflow design. Goal = trigger condition. Perception = data ingestion. Memory = context + retrieval. Reasoning = the model call. Tool use = API integrations. Action = write to DB, send message. Feedback = log outcome for evaluation.
04
## Building Workflows.
The practical how — from blank canvas to something running in production.
Before you build
### Map the failure modes first.
Draw the workflow. Then ask: what happens when the model returns garbage? What happens when the API is down? Every branch that leads to silent failure needs a fallback before you ship.
Connect a data source (email, form, webhook) → define what the AI model does with that data (classify, extract, generate) → wire the output to an action (update a record, send a message, trigger another step). The hard part is writing the prompt that's robust to edge cases — that takes iteration and logging, not just a clever initial draft.
Define a clear, measurable goal. Map chronological tasks. Assign ownership at each step (human or AI). Select tools. Build the happy path first, then stress-test with edge cases. The most common mistake is building the automation before establishing the baseline metric — if you don't know your current error rate, you can't prove the AI improved it.
In the context of responsible AI workflow design: Compliance (meets regulatory requirements), Confidence (can you quantify the model's certainty), Consistency (same behavior on similar inputs), and Clarity (can you explain the output). These aren't theoretical — they're the questions an auditor asks when a workflow makes a wrong decision at scale.
L1 handles routine, rule-based tasks. L2 handles exceptions with AI-assisted decision-making, escalating to humans when confidence is low. L3 handles complex, judgment-intensive tasks where AI augments human expertise. Deploy L1 broadly (high ROI, low risk), L2 selectively, and L3 sparingly — not because L3 isn't valuable but because it requires the most oversight.
05
## Challenges & Best Practices.
Why 85% of AI projects fail — and what the 15% do differently.
In production workflows, the biggest problem is lack of transparency in how models make decisions. When a workflow produces a wrong output, you need to know which step failed and why. Without logging and explainability tooling built in from day one, debugging becomes archaeology. Second biggest: data quality. Models are amplifiers — they amplify good data into great outputs and bad data into confidently wrong ones.
Top reasons: vague problem definition (no measurable success condition), poor data quality, underestimating deployment and monitoring cost, building for the demo rather than the edge case, and lack of domain expertise on the team. Most projects "fail" by not reaching production, not by producing wrong results. Getting to production is an organizational problem more than a technical one.
Core: prompt engineering, API integration, basic Python or JavaScript, data cleaning fundamentals. Differentiating: systems thinking (understanding how components fail), domain expertise, evaluation methodology (how do you score outputs?), and cost modeling (how do you prevent runaway API spend?). The actual bottleneck in most organizations is people who can scope, build, and evaluate a workflow end to end.
Accountability. A model can produce an output; only a human can own the consequence of acting on it. This is the non-technical moat for human workers in AI-augmented workflows. Design your workflows with explicit human ownership of outcomes, not just human review of outputs.
## Build faster with real data.
MCP Scraper gives your AI workflows the web intelligence they need — SERP data, People Also Ask harvests, page extraction, YouTube transcripts, and more. All via API or MCP server.
Start free →
---
## Claude Code: The Evaluation Guide Every Tutorial Skips
Canonical URL: https://mcpscraper.dev/blog/claude-code/
Published: 2026-05-24T00:00:00.000Z
Modified: 2026-05-24T00:00:00.000Z
The cost math, head-to-head comparisons, and trust answers that every Claude Code tutorial skips — so you can decide before you adopt.
01
## What Claude Code Actually Is
Most people who call Claude Code an "AI coding assistant" are describing a category it has already outgrown — it is closer to a junior engineer that runs in your terminal than a smarter autocomplete.
Built-in definition
### Claude Code operates on your full codebase, not just the file you have open.
Unlike Copilot or Cursor's inline suggestions, Claude Code reads your entire project tree, executes shell commands, runs tests, and commits — making it an agentic system , not an autocomplete extension.
Claude Code is an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools — available in your terminal, IDE, desktop app, and browser. It is not a chat interface you paste code into; it operates on your local filesystem, executes shell commands with your authorization, and can spawn parallel sub-agents on separate subtasks. Unlike autocomplete tools that react to the file you have open, Claude Code takes a goal as input and works through the steps to achieve it across however many files that requires. The distinction matters for evaluation: you are not buying a smarter tab-completion, you are buying an agent that can misunderstand goals, degrade in long sessions, and occasionally do exactly what you said instead of what you meant.
You describe a goal in natural language; Claude Code reads relevant files, writes or edits code, runs shell commands, and iterates until the task is complete — operating on your local filesystem throughout. The model (Claude Sonnet 4.6 by default, or Opus 4.7 for harder problems) holds up to 1M tokens of context, allowing it to reason across an entire medium-sized codebase in a single session. It runs a loop: read context, plan, execute, observe output, adjust — stopping when the goal is met or when it needs clarification. The practical implication is that prompt quality matters more than most tutorials admit: vague goals produce vague results, and Claude Code will complete a vague goal confidently.
Write and refactor code, run and fix tests, review pull requests, create scripts, set up CI/CD pipelines, manage files, and spawn parallel agents on subtasks — across any language or framework. Beyond code editing, Claude Code integrates with GitHub Actions and GitLab CI/CD natively, can trigger pull requests from a Slack mention, connects to external tools via Model Context Protocol (MCP), and can be scheduled as a routine that runs on Anthropic-managed infrastructure while your computer is off. The surface area is broad enough that the more useful question is what it cannot do reliably — and that list appears in Section 06.
Multi-file refactors, greenfield scaffolding, complex debugging cycles, and any task that requires reading a large codebase to understand context before making changes are where Claude Code's 1M-token context window creates a genuine capability gap over file-local autocomplete tools. It is also well-suited for tasks that require coordination across multiple steps — setting up a test suite, migrating an API client, or auditing a codebase for a specific pattern — where the work is too spread out for a single prompt in a chat interface. Where it underperforms: novel algorithmic design, highly domain-specific regulatory code, and real-time systems — detailed in Section 06.
It scores 80.8% on SWE-bench Verified — the leading benchmark for autonomous software engineering — and uses models with a 1M-token context window, allowing it to hold an entire medium-sized codebase in memory at once. The SWE-bench score means it solves roughly 4 in 5 real-world GitHub issues autonomously; competing tools score lower on the same benchmark. Context window size is the second structural advantage: autocomplete tools reason over hundreds of tokens; Claude Code reasons over millions, which is the difference between fixing a function and fixing a system. The 20% failure rate on SWE-bench is the equally important number — Section 06 covers what failure looks like in practice.
Claude Code is the first widely-adopted agentic coding tool that works at the project level rather than the file level , and it frequently completes tasks developers expected to take hours in under ten minutes — without requiring IDE changes or workflow restructuring. It runs in a terminal, which means it drops into any existing development environment without replacing the editor you already use. The combination of project-level context, shell execution, and a 1M-token window crossed a threshold where developers found themselves assigning real work to it rather than using it as a drafting aid — and that shift in how people use it, not any single feature, is what generated the adoption curve.
The underlying models — Claude Sonnet 4.6 and Opus 4.7 — were trained with a 1M-token context window and ranked first on SWE-bench ; paired with full filesystem access and shell execution, the capability gap over autocomplete tools is structural, not marginal. Most autocomplete tools use models optimized for next-token prediction in a small window; Claude Code uses models optimized for multi-step reasoning across large contexts — a different training objective that produces qualitatively different behavior. The important caveat for practitioners: benchmark performance reflects average case; your specific codebase, stack, and task distribution may diverge significantly from the benchmark distribution.
02
## Setup, Surfaces, and Who Can Use It
You do not need to be a developer to start a session with Claude Code — but the gap between "starting a session" and "getting reliable results" is wider than any installation guide will tell you.
Install via one curl command (`curl -fsSL https://claude.ai/install.sh | bash`), or use Homebrew (`brew install --cask claude-code`) on Mac or WinGet (`winget install Anthropic.ClaudeCode`) on Windows ; authenticate with a Claude Pro subscription or an Anthropic API key, then run `claude` in your project directory. The tool runs on macOS (Intel and Apple Silicon), Windows (x64 and ARM64), Linux, and WSL. A desktop application for macOS and Windows was also released on April 14, 2026, which adds a GUI launcher and Git worktree support for isolated parallel sessions. The fastest path to a first working session is the API key route — no subscription required, first session costs cents.
Yes — give it an empty directory and a description and it will scaffold the project structure, create files, initialize git, and write initial code without any existing codebase to read. This is one of the use cases where Claude Code's agentic loop is most visible: it plans the file structure, writes each file, runs an initial build to check for errors, and iterates — the same way a developer would approach a greenfield project. The caveat is that greenfield outputs still require review: Claude Code will make architectural decisions based on its training data, and those decisions may not match your team's standards, your target infrastructure, or your preferred dependencies.
Not for well-defined, bounded tasks — product managers and researchers have used it to run competitive analyses, clean data, and build simple automation — but verifying outputs and debugging failures still benefits from technical fluency. The gap that non-programmers run into is not starting Claude Code; it is recognizing when its output is wrong. Claude Code will generate syntactically valid code that does the wrong thing, use a deprecated API without flagging it, or misunderstand a requirement in a way that only becomes visible when the code runs. Knowing what "correct" looks like is a prerequisite for using any agentic coding tool reliably, and that knowledge does not come from the tool itself.
Yes, and beginners can complete real tasks in a first session — the friction of setup is low, the natural language interface is accessible, and for tasks with clear success criteria (write a Python script that does X, convert this CSV to JSON), the output is often directly usable. The challenge for beginners is the review step: knowing whether a diff is correct requires enough understanding of the code to evaluate it. The practitioner pattern that works for non-expert users is to use Claude Code for tasks where the output is directly testable — write a test, run it, see if it passes — rather than for tasks where correctness requires reading and understanding the generated logic.
For bounded, testable tasks — yes; for open-ended engineering work — no. The limiting factor is not the tool's interface but your ability to recognize when Claude has misunderstood the goal, which requires knowing what "correct" looks like for the specific task. Users without coding knowledge have successfully used Claude Code for data processing, file organization, simple script automation, and research tasks where the output is text or structured data they can evaluate directly. The failure mode is adopting it for work where correctness requires code comprehension — and then merging Claude's output without understanding it.
Yes — there is no restriction to commercial or professional use ; the Pro plan at $20/month or an Anthropic API key with pay-as-you-go billing both cover personal projects without restriction. Personal use cases that work well include automating repetitive file tasks, building personal utilities, learning a new language or framework by having Claude scaffold examples and explain them, and running competitive analysis scripts. The API key path is often more economical for personal use: if you spend under a few dollars per day on average, pay-as-you-go will cost less than the $20/month Pro subscription.
Technically yes, but it is an expensive and poorly-optimized path for conversation only — Claude Code is built for filesystem-aware, command-executing sessions, and for general conversation, Claude.ai is a better fit and may be cheaper depending on your plan. Running a chat-only session inside Claude Code consumes the same token budget as a coding session, which means you are burning rate-limit capacity on messages that would cost less (or nothing, on a free Claude.ai tier) in the standard interface. The one exception: if you are in the middle of a coding session and need to think through an architectural question without switching contexts, the terminal is a reasonable place to have that conversation.
Yes — you interact with Claude Code entirely through natural language prompts in the terminal , and you can store persistent instructions in a CLAUDE.md file in your project root so preferences, coding standards, and architectural decisions carry across sessions without re-stating them. The CLAUDE.md file is the most underused feature for teams: it allows you to encode your stack's conventions, preferred libraries, test patterns, and style rules once, so every Claude Code session starts with that context loaded. Practitioners who skip CLAUDE.md setup spend significantly more tokens re-explaining context that should be a project-level constant.
03
## The Real Cost Math Before You Commit
The subscription price is not the most important number — the ratio between what you pay at Max 5x versus what the same usage costs on raw API tokens is 18-to-1, and almost no review article publishes it.
Evaluation layer — what every tutorial skips
### You can run Claude Code today without a paid subscription.
An Anthropic API key unlocks full Claude Code functionality on a pay-as-you-go basis — no $20/month Pro plan required. The average developer spends about $6 per day at API rates; for light users, this path is cheaper than a monthly plan and removes the cost-before-commit barrier entirely.
There is no free Claude Code plan , but you can use it without a subscription by providing an Anthropic API key and paying per token — and for light users, this often costs less per month than the $20/month Pro subscription. The Free plan on Claude.ai does not include Claude Code access. The API key path requires a funded Anthropic account but no minimum spend: a few evaluation sessions will cost a few dollars, not $20. The distinction matters: "no free plan" and "no way to try it without committing $20" are different conditions, and almost every article conflates them.
Not for free with Claude models , but Claude Code can be configured to run against local Ollama-compatible models, which eliminates API costs entirely — at the cost of model quality relative to Claude Sonnet 4.6. Running Claude Code against a local Ollama model means all inference stays on your machine: no API call, no token spend, no data leaving your network. The trade-off is that local open-source models perform significantly below Claude Sonnet 4.6 on SWE-bench and similar coding benchmarks, so the output quality for complex tasks is not comparable. For privacy-sensitive experimentation or cost-zero prototyping, local Ollama is a legitimate path; for production coding work, the quality gap is real.
The API key path requires a funded Anthropic account, but there is no minimum spend — you can run several evaluation sessions for a few dollars without committing to any monthly plan. Create an Anthropic account, add a small credit balance ($5–$10 is enough for meaningful evaluation), generate an API key, and authenticate Claude Code with it. At Sonnet 4.6 rates ($3/MTok input, $15/MTok output), a few hours of coding sessions will cost well under $10. This is the evaluation path that no ranking article describes explicitly, which is why most searchers believe the choice is binary: $20/month Pro or nothing.
No — the Free plan does not include Claude Code access ; the tool requires Pro ($20/month), Max ($100–$200/month), Team Premium ($100–$125/seat/month), or an Anthropic API key with pay-as-you-go billing. As of 2026-05-24, Anthropic has not announced a free tier for Claude Code. The "free" path that does exist is the API key route for low-volume users who spend less monthly than the Pro subscription would cost — which is free of subscription commitment but not free of per-token cost. If you are searching this question because you saw "free" mentioned somewhere, it likely refers to the absence of a required subscription for the API key path, not zero-cost access.
Pro: $20/month (or $17/month billed annually); Max 5x: $100/month; Max 20x: $200/month; Team Premium: $125/seat/month (or $100/seat/month annually), minimum 5 seats, Claude Code included; API key: pay-as-you-go, average approximately $6/developer/day. Team Standard ($25/seat/month) does not include Claude Code. The Max plans exist because Pro has a usage ceiling — approximately 44,000 tokens per 5-hour window — that active power users hit daily; Max 5x roughly doubles that to 88,000 tokens, and Max 20x reaches approximately 220,000 tokens per window. For developers who would otherwise pay API rates at those volumes, the Max plan is dramatically cheaper than the alternative.
At Pro ($20/month), the break-even is roughly one hour of professional developer time saved per month — for developers using it daily on real tasks, the ratio is heavily favorable. The harder question is whether you need Max-tier throughput: if you hit the Pro usage ceiling regularly, you are spending time waiting for windows to reset instead of working, and the $80/month step-up to Max 5x pays for itself quickly. For occasional users — a few sessions per week on bounded tasks — the API key path at average $6/developer/day will cost less than $20/month and provides the same capability without the subscription commitment.
For developers running multi-file tasks daily, yes — the Max plan is approximately 18x cheaper than equivalent API usage at full capacity ; for occasional users, the API key path is more economical and the subscription adds no value. The 18x figure comes from the projected cost of purchasing the same token volume directly at Sonnet 4.6 rates ($3/MTok input): at Max 20x throughput sustained, the API equivalent would run approximately $3,650/month versus $200/month for the Max 20x plan. The honest framing for an evaluation decision: start with the API key path, measure your actual daily spend for two weeks, then decide whether the Pro or Max subscription saves money relative to your real usage pattern.
Light use on an API key: under $2/day; moderate use on Pro: $20/month flat; heavy agentic use on Max 5x: $100/month for approximately 88,000 tokens per 5-hour window , versus approximately $3,650/month if you paid API rates for the same volume. Ninety percent of API-path users spend under $12/day. Prompt caching reduces costs further for long sessions with repeated context: Sonnet 4.6 cache reads cost $0.30/MTok versus $3/MTok for fresh input — a 90% discount on context that is already in the cache. The Batch API adds a 50% discount across all token prices for non-real-time workloads. Heavy users who ignore caching and batching pay 2–3x more than necessary.
Claude Code remains available on the Pro plan — the Max plans (5x and 20x) are higher-throughput tiers added for power users, not replacements for Pro. Pro was not removed or downgraded; it retains the same model access (Sonnet 4.6 and Opus 4.7) as Max, with tighter usage limits per 5-hour window (approximately 44,000 tokens). The confusion likely stems from Anthropic's introduction of the Max tier, which is marketed heavily to power users — but Pro is still the primary entry point for individual developers who do not consistently hit usage ceilings.
04
## Claude Code vs. the Tools You Already Use
The three tools most developers compare against Claude Code — Cursor, GitHub Copilot, and ChatGPT — answer different questions than Claude Code does, and picking the wrong framing makes the comparison meaningless.
Decision-stage question the SERP ignores
### Most professional teams use Claude Code alongside Cursor or Copilot, not instead of them.
The most common production stack is Cursor for inline editing (72% autocomplete acceptance rate with Supermaven) + Claude Code for complex multi-file tasks in the terminal — or Copilot in the IDE + Claude Code for architectural work. Picking one and dropping the other is a false choice.
Claude's models score higher on coding benchmarks (80.8% SWE-bench Verified) and have a substantially longer context window (1M tokens versus 128k for GPT-4o) , and Claude Code offers deeper filesystem integration than ChatGPT Codex or the GPT-4 API. For developers specifically, the context window difference is the most consequential: 1M tokens allows Claude Code to reason over an entire codebase; 128k limits competing tools to a subset of files. The SWE-bench gap is real but less dramatic than marketing implies — both tools fail a meaningful percentage of tasks, and the right comparison is not benchmark scores but how each tool behaves on your specific workload.
For agentic coding tasks, Claude Code leads on SWE-bench Verified at 80.8% ; for general conversation, document analysis, and multimodal tasks, the gap between the two is smaller and depends on the specific benchmark. Neither is universally better: GPT-4o has advantages in certain multimodal contexts; Claude Sonnet 4.6 leads on long-context coding tasks. The evaluation question for a developer is not "which is better overall" but "which handles my workload better" — the two tools have different context window sizes, different pricing structures, and different agentic execution models, and those differences matter more than aggregate benchmark rankings.
The three primary reasons developers cite: longer context window (1M versus 128k), stronger agentic task performance on SWE-bench, and Claude Code's full-filesystem terminal approach versus chat-based alternatives. A secondary factor is Constitutional AI training, which produces a model that more often says "I don't know" or flags uncertainty rather than generating confidently wrong output — a meaningful difference for code review workflows where false confidence is costly. Developers who switched from ChatGPT-based workflows most commonly cite hitting GPT-4o's context limit on large codebase tasks as the triggering event.
GitHub Copilot Pro at $10/month is the lowest-priced individual plan in this comparison : ChatGPT Plus is $20/month, Claude Pro is $20/month, and Cursor Pro is $20/month. Copilot also offers a team plan at $19/seat/month and enterprise at $39/seat/month. The price comparison is misleading without capability context: Copilot at $10/month provides IDE-integrated autocomplete and code chat; it does not include a standalone agentic coding tool equivalent to Claude Code. Developers who need both inline autocomplete (Copilot's strength) and multi-file agentic task completion (Claude Code's strength) are looking at $10 + $20 = $30/month minimum, not a choice between them.
Both hallucinate; the more useful comparison for coding tasks is SWE-bench score , which measures how often a model actually solves a real-world issue correctly rather than generating plausible-looking wrong code — and Claude Code leads at 80.8%. Claude's Constitutional AI training is designed to produce more calibrated uncertainty: the model is more likely to say it does not know something than to confabulate a confident but wrong answer. In practice, both tools will generate syntactically valid code that fails tests, fabricate library method names, and misread logic — the difference is in frequency and in how they signal uncertainty. For any coding output from either tool, running tests and reviewing diffs is non-optional.
Ollama runs open-source language models locally on your machine; Claude Code can be configured to use Ollama-compatible models as its backend, eliminating API costs and keeping all data entirely local. This configuration is relevant for two use cases: cost-zero experimentation without API spend, and air-gapped or high-security environments where sending code context to an external API is not permissible. The trade-off is model quality: local open-source models perform significantly below Claude Sonnet 4.6 on SWE-bench and complex coding tasks. The Ollama path is worth knowing because most articles presenting Claude Code as requiring a paid subscription omit it entirely — for teams with strong privacy requirements or zero budget, it is the only viable evaluation path.
05
## Safety, Data Handling, and What Claude Code Can Actually See
The most common trust concerns about Claude Code — screenshot access, code ownership, data leakage — have clear factual answers, and none of the ranking articles provide them.
Enterprise and privacy-sensitive teams
### Claude Code does not store your code on Anthropic's servers between sessions.
Your files run locally on your machine; only the conversation context (your prompts and Claude's responses) is sent to Anthropic's API. The Enterprise plan adds HIPAA-ready data handling , audit logs, custom data retention controls, and SCIM provisioning — features that unblock adoption for regulated industries.
For most professional use, yes — code executes locally, file access is local, and only prompt context traverses the API ; sensitive or regulated data (HIPAA, PII) requires the Enterprise plan for compliant data handling. The practical risk surface for most developers is not data leakage but local command execution: Claude Code executes shell commands you authorize, and approving a destructive command without reviewing it produces real damage. For teams in regulated industries, the Enterprise plan adds HIPAA-ready data handling, audit logs, and custom data retention controls — the specific features required for compliant adoption in healthcare, finance, and similar sectors.
Yes — Anthropic's usage policies apply to Claude Code, and automated or agentic misuse can trigger account suspension. The prohibited uses are the same as those that apply to Claude.ai: generating malware, automating scraping in violation of a site's terms, producing content that violates Anthropic's usage policy, and misrepresenting Claude-generated output as human-authored in contexts where that matters. Agentic tools that execute at scale create higher-velocity policy surface than chat interfaces — a Claude Code routine running unattended can produce policy violations faster than a human would catch them. Review Anthropic's usage policy before deploying Claude Code in automated, unmonitored pipelines.
No evidence of systemic data leakage exists ; prompt context is transmitted to Anthropic's API as part of normal operation but is not persisted beyond the session by default under standard plans. What "leak" means technically: your code appears in the prompt context sent to the API for inference; it is not stored, indexed, or accessible to other users. Enterprise plans add explicit custom retention controls and data-use opt-outs for teams who need contractual data handling guarantees rather than policy-level assurances. The meaningful risk for most teams is not leakage to other users but the transmission of proprietary code to an external API at all — a policy question, not a technical vulnerability.
The primary risk surface is local command execution, not network security — Claude Code executes shell commands you authorize on your machine, and approving a destructive command without reviewing it produces damage that is real and often irreversible. Claude Code's design requires your explicit approval before executing commands in most configurations, but users who approve commands quickly without reading the proposed action bypass the primary safety mechanism. The secondary risk is prompt injection in multi-agent configurations — a subtask agent receiving malicious instructions from an external source. Neither risk is exotic; both are manageable with standard review practices.
Trust is context-dependent: for local development tasks, yes; for regulated data, only under the Enterprise plan; for security-sensitive environments, verify the data handling documentation before adopting. The relevant trust question for most practitioners is not "is Anthropic malicious" but "does sending my codebase context to an external API comply with my organization's data handling policy" — and that is a legal and compliance question, not a technical one. Enterprise teams evaluating Claude Code should request Anthropic's data processing agreement and review the HIPAA-ready configuration before making adoption decisions; the documentation exists and is specific.
No — Claude Code does not have screen capture capability. It reads and writes files on your filesystem and executes terminal commands, but it cannot capture your screen, access your clipboard, read data from applications outside the project directory you opened it in, or observe your browser activity. The question comes up because agentic AI tools are often conflated with general system-access tools; Claude Code's access is specifically scoped to your project directory and the shell commands you authorize it to run. If you are evaluating Claude Code for an environment where screen capture would be a security concern, that concern does not apply to this tool's architecture.
OpenAI's standard terms do not claim ownership of output code , and Anthropic's terms similarly do not claim ownership of code that Claude Code generates — but both companies' default terms may use your inputs to improve their models unless you opt out or upgrade to an enterprise plan. For most developers, code ownership is not the risk: the risk is whether code you submit as input context can be used in model training. Anthropic's Enterprise plan includes explicit data-use opt-outs; OpenAI's Enterprise plan does the same. On individual plans for either tool, review the current terms of service for training data opt-out provisions, which have changed multiple times across both platforms.
Some organizations block Claude via firewall because it is an external API service — not because of a known security vulnerability in Claude specifically. IT departments that treat all AI API services as unauthorized external data connections will block Claude Code, ChatGPT, Copilot, and similar tools under the same policy, regardless of their individual security properties. The blocking is a data governance decision, not a technical finding against Claude. For enterprise teams trying to get Claude Code approved through IT, the relevant artifacts are Anthropic's data processing agreement, the HIPAA-ready Enterprise configuration documentation, and Anthropic's SOC 2 compliance status — not the tool's general reputation.
06
## What Claude Code Gets Wrong (And What It Cannot Do)
The performance ceiling that marketing materials never publish: Claude Code hallucinates, degrades in long sessions, and will confidently generate plausible-looking wrong code — knowing the failure modes before you adopt matters more than knowing the benchmark score.
Novel algorithmic design requiring mathematical proof, highly domain-specific regulatory code with no training signal, real-time systems where every millisecond matters, and tasks requiring external context it cannot access — production databases, proprietary internal documentation, undocumented internal APIs — are the consistent failure categories. Claude Code reasons over what is in its context window; anything that must be inferred from systems it cannot read produces hallucinated or superficially correct but functionally wrong output. The most expensive failure mode in practice is not obvious errors but plausible-looking code that passes a surface review and fails in production — which is why running tests is not optional.
Yes — rate limits vary by plan: Pro gets approximately 44,000 tokens per 5-hour window; Max 5x approximately 88,000; Max 20x approximately 220,000 ; hitting the ceiling pauses access until the window resets. These are approximate figures derived from usage reports; Anthropic does not publish the exact token limits by plan. The practical effect: heavy Pro users who run multiple long agentic sessions in a day will hit the ceiling and wait; Max 5x handles most power-user workflows without interruption. On the API key path, there are no usage windows — you pay per token with no ceiling, which is one reason the API path can be preferable for users who need uninterrupted long sessions.
Claude Code is not being degraded — Anthropic has not reduced model capability ; perceived quality drops in long sessions typically trace to context window saturation, not model downgrade. When a session accumulates enough turns that older context is compressed or dropped to fit within the context window, Claude Code loses access to earlier decisions, file states, and constraints — and the output quality degrades visibly. The fix is to start a new session for major new tasks rather than extending a single session indefinitely. The "getting dumber" perception is real; the cause is session management, not model regression.
Yes — it will generate incorrect code, fabricate library method names, and misread file logic , and the SWE-bench score of 80.8% means it fails roughly 1 in 5 real-world tasks by the benchmark's definition. Hallucination in coding contexts looks different from hallucination in conversation: the output is syntactically valid, the method names look plausible, and the logic structure appears correct — it fails when you run it. Always run tests and review diffs before merging Claude Code output; treating it as authoritative without validation is the most common source of expensive errors. The 80.8% score is the performance ceiling under benchmark conditions; your specific codebase, stack, and task distribution will produce a different empirical failure rate.
Not with Claude models — all inference goes through Anthropic's API, which requires an active internet connection. The exception is running Claude Code configured against local Ollama-compatible models, which work fully offline with no API call required. For teams in air-gapped environments or with strict egress policies, the Ollama configuration is the only viable path to offline Claude Code use — at the cost of model quality. Anthropic does not currently offer an on-premises deployment option for Claude models equivalent to some enterprise AI vendors; the Enterprise plan provides stronger data handling guarantees but still routes inference through Anthropic's API.
For developers running multi-file refactors, complex debugging cycles, or greenfield scaffolding, yes — the SWE-bench benchmark performance and consistent practitioner time-savings reports are aligned ; for users expecting zero-verification autonomous output, no. The honest evaluation frame: Claude Code is a force multiplier for developers who can review its output, not an autonomous agent that eliminates the need for developer judgment. Teams that have adopted it most successfully use it for the high-context, high-effort tasks that benefit most from 1M-token reasoning — not as a replacement for understanding the codebase.
As of mid-2026, Claude Code leads on SWE-bench Verified at 80.8% and on context window size at 1M tokens ; Cursor leads on inline autocomplete acceptance rate at 72% with Supermaven; the "best" answer depends entirely on whether you optimize for agentic task completion or IDE-native editing speed. The benchmark lead is real but not permanent: SWE-bench scores across competing tools have risen steadily, and the gap between leaders narrows with each model generation. The more durable evaluation criterion than benchmark ranking is which tool handles the specific failure modes that matter most in your codebase — which requires empirical testing, not reading rankings.
## Scrape smarter with real web data.
MCP Scraper gives your Claude Code agents the live web intelligence they need — SERP data, People Also Ask harvests, competitor page extraction, and structured data feeds — without rate limits or browser fingerprinting.
Start free →
---
## People Also Ask SEO: The Complete 2026 Guide
Canonical URL: https://mcpscraper.dev/blog/people-also-ask-seo/
Published: 2026-05-24T00:00:00.000Z
Modified: 2026-05-24T00:00:00.000Z
What PAA boxes are, how Google generates them, which tools harvest them at scale, and why the manual two-step loop breaks the moment you need programmatic data.
01
## What Is People Also Ask?
PAA mechanics, Google behavior, and what the AI-generation shift means for the feature — the foundational questions most guides leave unanswered.
Key take
### PAA is not a content placement. It is a real-time map of query intent.
Google surfaces PAA on roughly 85% of searches. Winning a placement is useful. Understanding why Google shows the questions it does — and how 12.6% of answers are now AI-generated — is what separates a tactic from a strategy. Optimize the placement. Understand the system.
People Also Ask (PAA) is a dynamic SERP accordion Google introduced in 2016 that surfaces related questions predicted to follow a searcher's original query. It now appears on roughly 85% of searches — not a niche placement opportunity but a near-universal feature that functions as Google's real-time map of query intent for every topic. Early testing began in April 2015 as "Related questions" before the official July 2016 naming. For SEOs, PAA is two things simultaneously: a visibility placement to win, and a research signal showing which follow-up questions Google believes matter most to your searchers.
Google generates PAA algorithmically from co-occurrence patterns in search sessions — which queries follow which, and what content satisfies them. One significant recent shift: 12.6% of PAA answers are now AI-generated by Google itself , not pulled from any web page. This means winning a PAA placement no longer guarantees your content is the displayed source. The answer Google shows may be synthesized entirely from its own models, with your page as a citation at best. Understanding this shift changes the strategic goal from "win the placement" to "be the authoritative source Google trusts when it generates the answer."
"People also searched for" is a distinct SERP feature — it appears after a user clicks a result and returns to the search page, surfacing refinement queries based on what searchers do next. PAA appears before the click , predicting follow-up intent from the query itself. They signal different moments in the search session and target different optimization strategies. "People also searched for" is a post-click refinement signal; PAA is a pre-click intent prediction. Conflating the two leads to misaligned content strategy — targeting refinement queries when your page needs to answer the predicted follow-ups, or vice versa.
PAA boxes are infinite-scroll : expanding one question loads 2–4 additional questions, allowing Google to map an entire topic graph from a single seed query. The block appears after the first organic result in more than 58% of SERPs , making it a top-three SERP element in roughly two-thirds of all searches. Featured answers average 40–50 words . The infinite-scroll mechanism is the most operationally important detail for SEOs: a single seed keyword can branch into hundreds of related questions, which is why harvesting PAA programmatically returns a fundamentally different volume of data than manually expanding a visible accordion.
Three methods, in order of scale: manual SERP expansion — open Google, type your keyword, click the accordion arrows (free, works at 1–5 keywords); UI tools like AlsoAsked , which automate question collection and return visual question trees ($12–$47/mo, works at 5–1,000 keywords); and programmatic API access via MCP Scraper , which returns structured PAA data for any keyword without a browser (works at any scale). The right method depends entirely on how many keywords you need to cover. The manual path is not inferior — it is simply volume-limited, and that limit arrives faster than most SEOs expect.
PAA avoids four structural categories: highly time-sensitive breaking news (where no authoritative answer has stabilized), deeply personal queries (medical, legal, financial specifics tied to individual circumstance), normative controversies where no consensus source exists, and queries where the intent is too ambiguous for any single question formulation to make sense. Understanding these boundaries helps SEOs identify where PAA placements are structurally off the table — not due to competition, but due to feature design. If your topic falls into one of these categories, optimize for other SERP features rather than PAA.
How many PAA questions does one keyword unlock? Seed keywords 3 Expansion depth (click levels) 2 12 questions visible manually 252 questions in the full PAA tree
02
## PAA as an SEO Strategy
Intent mechanics, keyword discovery, and why PAA is a top-5 SEO strategy because of AI Overviews — not despite them.
The number that changes the strategy
### Purchase-intent PAA queries drive 13.6% interaction rates. Overall PAA: 3%.
The 4× gap is not a curiosity — it is the entire prioritization framework. Which questions are worth targeting first is a data problem, and the data problem requires harvesting tools, not intuition.
The four intent types — informational, navigational, commercial, transactional — are not equally valuable in PAA strategy. Purchase-intent queries drive a 13.6% PAA interaction rate , versus 3% for searches overall. That 4× gap means intent classification is not just a content exercise — it is the highest-leverage variable in deciding which PAA questions are worth targeting first. Most SEO teams apply intent classification to keyword strategy but never extend it to PAA prioritization. Applying it there is the arbitrage: harvest PAA for purchase-intent and commercial queries first, and the ROI per question answered separates immediately from the pack.
Content type, content format, and content angle — the 3 C's — determine structural eligibility for a PAA placement before Google evaluates topical relevance. Format matters most : PAA answers average 40–50 words, which means a 2,000-word section cannot win a placement regardless of its quality. PAA requires an extractable, self-contained answer at the right word count. The content angle determines whether your framing matches the specific question Google is showing — a page that answers the general topic but not the exact question in the accordion is not eligible. The 3 C's applied to PAA become a pre-qualification checklist, not an afterthought.
Applied to PAA, the 80/20 rule holds in the data: the 13.6% interaction rate for purchase-intent queries versus 3% overall suggests that a small subset of PAA questions drives disproportionate engagement and commercial value. Identifying that subset — by intent type and query category — is precisely what PAA harvesting tools solve, because the questions that matter most are rarely obvious from the seed keyword alone. A human reviewing a SERP accordion sees 4 questions. A programmatic harvest of the full PAA tree for that seed can surface 200. The 80/20 rule applies to that full dataset, not to the visible 4.
For PAA strategy specifically, a complete stack looks like: Google Search Console (free, shows existing PAA appearances for your domain), AlsoAsked (UI-based question trees, $12–$47/mo, best for manual research up to 1,000 seeds), Semrush (broad SERP feature tracking), and MCP Scraper (programmatic PAA API for pipeline integration). The right combination depends on whether your workflow is UI-based or data-pipeline-based. Teams doing content at scale need both tiers — the UI tool for ad-hoc research and the API for systematic collection. The two are complementary, not competing.
For PAA research specifically, Google Search Console is the strongest free starting point — it shows which PAA features your site already appears in, at no cost. AlsoAsked offers free monthly credits without requiring a registered account. MCP Scraper is not the beginner recommendation; it requires API literacy and suits developers moving into structured data workflows, not first-time SEOs. The honest path for a beginner: start with Search Console to see what you already have, use AlsoAsked free credits to map the questions you're missing, and add the API layer when manual research becomes the rate-limiting step in your workflow.
PAA optimization earns a top-5 slot not because its direct interaction rate is high (3% overall) but because of its relationship with AI Overviews: PAA co-appears with AI Overviews in 90% of cases . Winning a PAA placement now doubles as qualifying content to be sourced by AI Overviews — a compound visibility return that traditional link-building cannot replicate. Optimizing for PAA is, in practice, optimizing for AI Overview sourcing eligibility. The 90% co-appearance figure means these two features share the same content signal. Teams that ignore PAA are leaving the most reliable AI Overview proxy on the table.
Is your PAA strategy leaving data on the table?
Do you prioritize PAA questions by intent type — targeting purchase-intent questions before informational ones?
Yes — intent drives my question selection No — I target all PAA questions equally
Do you refresh PAA-targeted content at least once per quarter?
Yes — freshness is part of my process No — I optimize once and move on
Is your target keyword list larger than 50 keywords?
Yes — 50 or more keywords No — fewer than 50
03
## AI and the Future of PAA
Is SEO dead? Will AI replace it? Committed answers backed by data — including why AI Overviews make PAA more important, not less.
Counter-intuitive finding
### AI Overviews make PAA more important, not less.
PAA co-appears with AI Overviews in 90% of searches. Winning a PAA placement is currently the most reliable proxy for AI Overview sourcing eligibility. The teams abandoning PAA because of AI are removing themselves from the exact feature that signals AI citation readiness.
Structurally shifting, not dying — but the shift is significant. 58.5% of US Google searches already end without a click. AI Overviews reduce position-1 CTR by up to 58%, and searches triggering AI Overviews show an 83% zero-click rate. PAA co-appears with AI Overviews in 90% of cases. The game has moved from generating clicks to being cited as an answer source — visibility without click-through is the new baseline. The SEOs who treat this as a crisis are measuring the wrong thing. The SEOs who treat it as a repositioning opportunity are already optimizing for sourcing frequency, not position rank.
AI is not replacing SEO — it is automating the parts that were manual and amplifying the parts that require data access. The practitioners who win are those using AI for content generation while feeding it with live, structured SEO data: PAA trees, SERP features, intent signals. The ones who lose are optimizing one page at a time while their competitors run data pipelines that update daily. The replacement narrative confuses the tool with the discipline. SEO as structured analysis of how content earns visibility in search systems is not going anywhere. The execution layer is being automated. The strategic layer is becoming more valuable, not less.
The emerging term is answer-engine optimization (AEO) — structuring content so AI systems cite it as a source, not just rank it in blue links. PAA boxes are currently the most reliable signal for what questions AI Overviews will answer from a given domain, because the two features co-appear in 90% of cases . Winning PAA now is training data sourcing practice for the AI-first SERP. AEO is not a replacement for SEO — it is an extension of it toward the citation layer. The content signals that earn PAA placements and the signals that earn AI Overview citations overlap significantly. PAA optimization is AEO in its most accessible form.
ChatGPT can draft content but cannot perform PAA research — it has no live SERP access, returns no real-time question clusters, and cannot tell you which questions Google is surfacing for your keyword today. PAA data is a live signal that requires querying the SERP, not a language model. Any AI-assisted SEO workflow that skips a live data layer is building content strategy on stale assumptions. The correct architecture is: live PAA data (from a harvesting API) feeding structured inputs to the LLM, with the LLM handling drafting and the data layer handling research. Skipping the data layer produces well-written answers to questions no one is actually asking.
ChatGPT can review content structure , flag missing headers, and suggest improvements to on-page copy — but it cannot audit live SERP features, check which PAA questions your competitors currently hold, or identify PAA placement gaps across your keyword set. Those tasks require real-time structured data pulled from the SERP itself, not pattern-matching against training data. The distinction is not about writing quality — it is about data access as a category. LLM-based audits are useful for qualitative content review. They are structurally incapable of competitive PAA analysis, which requires live harvesting at query time.
No single AI model is "best for SEO" — the question frames it wrong. The winning configuration is: a live data API (PAA harvesting, SERP feature extraction) feeding structured inputs to an LLM for content generation and optimization. The AI model handles language; the data layer handles reality. MCP Scraper occupies the data layer slot — it supplies the question data that makes content decisions defensible rather than intuitive. Conflating the two is why AI-assisted SEO often produces content that reads well but targets the wrong questions. The model choice matters far less than whether your workflow has a live data layer at all.
Quick check
PAA co-appears with AI Overviews in what percentage of searches?
The 90% co-appearance rate is the number that changes everything — winning a PAA placement is currently the most reliable proxy for AI Overview sourcing eligibility. Teams abandoning PAA because of AI are removing themselves from the exact signal that governs AI citations.
04
## PAA Tools Compared
AlsoAsked vs. Semrush vs. MCP Scraper — honest tradeoffs, including where MCP Scraper is and is not the right choice.
AlsoAsked crawls Google PAA boxes for a given keyword and builds a branching tree of related questions, which it presents as a visual map, PNG export, or CSV. Bulk upload processes up to 1,000 seed terms in a single job, returning a large question set from recursive PAA expansion. It includes multi-region and multi-language support, API access, and webhook integration across all paid tiers. AlsoAsked is best positioned for UI-based workflows where a researcher is manually reviewing and selecting questions. The limit of the approach is pipeline integration: CSV exports require a human in the loop, and the API, while available on all paid tiers, is designed around the same single-query model as the UI.
AlsoAsked offers free monthly credits for non-registered users, with no credit card required. Paid plans start at $12/mo (Basic, 100 credits) and go to $47/mo (Pro, 1,000 credits); the $23/mo Lite tier (300 credits) is listed as most popular. Annual billing saves 20%. All paid tiers — including Basic — include API access , so the API is not gated behind a premium plan. The free tier is genuinely useful for occasional PAA research. The paid tiers are priced for practitioners doing regular question harvesting. The $12 Basic plan is a legitimate entry point for SEOs who need more than the free credits allow but are not yet at pipeline scale.
Technical, on-page, off-page, and content — the traditional four pillars — are all affected by PAA strategy. But the content pillar increasingly depends on the technical pillar for data access: a content team that cannot harvest PAA programmatically is relying on manual research that caps out at dozens of keywords. The teams closing content at scale have connected their data layer directly to their publishing pipeline. PAA strategy now bridges two pillars simultaneously. The content question ("which questions should we answer?") is answered by the technical infrastructure ("what does the PAA API return for this seed keyword?"). That bridge is the competitive gap most content teams have not crossed.
A beginner can start PAA research immediately — free tier on AlsoAsked (no account required), Google Search Console for existing rankings, and manual SERP expansion for small keyword sets. The step-change to programmatic PAA requires basic API literacy, not advanced SEO expertise. Developers entering content teams are often better positioned for the API path than experienced SEOs who have never worked with structured data outputs. The entry barrier is not SEO knowledge — it is familiarity with REST APIs and JSON. A developer who has never done SEO can integrate the MCP Scraper API faster than an experienced SEO who has never touched an API endpoint.
Solo SEOs can run effective PAA strategy — the manual workflow handles 1–5 target keywords well . The friction hits at roughly 50 keywords: at that volume, manually expanding PAA trees and logging questions becomes the rate-limiting step, not the content writing. The programmatic API path is the unlock at scale, not a requirement for getting started. The honest threshold: if your keyword list fits on one spreadsheet page and you update it quarterly, manual PAA research is sufficient. If your keyword list is dynamic, multi-locale, or feeds an automated content system, the API path pays for itself in the first week of research time saved.
Pick a tool to compare
AlsoAsked — UI-based PAA question trees
- Visual question tree with PNG and CSV export
- Free tier with no account required
- Bulk upload up to 1,000 seeds, multi-region support
- CSV export requires human review in the loop
- API mirrors the single-query UI model — not designed for pipeline volume
Best for UI-based research at up to 1,000 seeds per month. The right tool when a researcher is manually reviewing and selecting questions.
Semrush — Full SEO suite with PAA tracking
- PAA alongside rankings, backlinks, and site audit in one platform
- Historical SERP feature data for trend analysis
- PAA is not its primary strength — depth limited vs. dedicated tools
- Expensive if PAA is your only use case
- No programmatic extraction of full PAA trees
Right if you already use Semrush for keyword research and want PAA visibility added. Overkill for PAA-only workflows.
MCP Scraper — Web dashboard + API + MCP server
- Dashboard at mcpscraper.dev: run PAA, SERP, Maps, YouTube, and Facebook Ads from one UI
- Same data available via REST API and as MCP tools for Claude, Cursor, and Copilot
- Full PAA tree per seed, results as cards or structured JSON/Markdown export
- Covers seven surfaces — more than you need if PAA is your only use case
- Credit-based billing: each surface costs credits, not a flat subscription per tool
Right when you need PAA alongside SERP data, Maps intelligence, or competitive ad research — and when you want the same data accessible to both your team and your AI agents.
05
## Scaling PAA Extraction
The programmatic case — why the manual UI loop breaks at scale, and what a PAA data pipeline actually looks like.
The scale threshold
### PAA questions shift by location, device, language, and time. Scraping them once is not a strategy.
Google mines search sessions continuously. PAA is a live signal, not a static dataset. Recurring programmatic harvesting on a schedule is the correct workflow for any live content operation — not a one-time manual pull followed by a spreadsheet filed away.
Applied to PAA at scale, five concepts that drive results: query intent mapping (which questions signal purchase-readiness), zero-volume question discovery (PAA surfaces questions that keyword tools miss entirely), PAA tree traversal (one seed keyword branches into hundreds of related questions), freshness signaling (content updated within 90 days appears 4.3× more frequently in PAA features), and structured data delivery . The last four require programmatic access. The freshness multiplier is the most underused lever in PAA strategy — most teams optimize the answer once and move on, missing the ongoing recency advantage that recurring updates deliver.
At programmatic scale, the three operational pillars become data acquisition, content production, and distribution — not the traditional crawlability, content, and authority. PAA harvesting via API sits at the data-acquisition layer, upstream of every content and publishing decision. MCP Scraper operates at that layer: it does not write content or build links, it supplies the question data that makes content decisions defensible rather than intuitive. The scope boundary is a trust signal: a tool that claims to do everything does nothing well. The data acquisition layer is the one most content teams have not built yet — and it is the layer that compounds.
Content, code, and credibility — but in a programmatic PAA workflow, "content" starts upstream with machine-readable question data , not a brainstorming session. The gap between "which questions should we answer" and "draft created" collapses when PAA API output feeds directly into a content brief template or LLM prompt. The manual research phase that typically takes days becomes a sub-second API call . The "code" pillar is what enables this — a REST endpoint that accepts a seed keyword and returns a structured PAA tree is not a luxury for large teams; it is the unlock that makes content operations at any scale less dependent on individual research time.
Google's 20% rule — the practice of giving engineers discretionary time for side projects — produced features including Gmail and Google Maps. PAA itself emerged from the same underlying logic : Google continuously mines search session data to predict follow-up intent. That mining is live and ongoing, which is why PAA questions shift by location, device, language, and time — and why scraping them once and filing the results is not a strategy. Recurring harvesting on a schedule is. The operational implication: build a workflow that pulls PAA data for your priority keyword set on a monthly or weekly cadence, and treat the outputs as a live editorial signal, not a one-time research deliverable.
PAA pipeline setup 0 / 5 done
- Define your seed keyword list — start with your top 50 pages by traffic
- Choose your extraction method: manual for ≤10 keywords, API for 50+
- Classify PAA output by intent type — prioritize purchase-intent questions first
- Set a freshness schedule — monthly for competitive topics, quarterly for stable ones
- Connect PAA output to your content brief template or LLM prompt
06
## Practical PAA Tactics
Quick wins, freshness mechanics, anti-bot realities, and why the programmatic path is where SEO income separates.
The baseline PAA skill set is: reading query intent accurately , writing concise Q&A answers (40–50 words is the PAA sweet spot), implementing FAQ and HowTo schema markup , and maintaining content freshness — pages updated within 90 days appear 4.3× more frequently in PAA features than stale content. The advanced skill is API integration for teams transitioning to programmatic workflows. The basics above are achievable without any tooling beyond Google Search Console, and they compound: intent-matched 40-word answers with correct schema and a quarterly update cadence will outperform longer, less-structured content on PAA placements across nearly every category.
PAA-driven SEO is splitting into two earning brackets. Practitioners who optimize content manually — identifying questions, formatting answers, checking rankings — are doing work that AI tools increasingly replicate, which compresses rates. Practitioners who build PAA data pipelines and integrate them into content systems are doing technical-strategic work that remains rare. The programmatic path is where income separates, not because it is harder to learn, but because few people have crossed the data-engineering threshold yet. The "data-engineering threshold" is lower than it sounds: REST API literacy, basic JSON handling, and familiarity with content pipeline tooling. The gap is not a skills gap — it is an awareness gap.
CAPTCHA and anti-bot verification appear when collecting PAA data without proper infrastructure. Headless browsers sending high-frequency requests without realistic session behavior, residential proxy coverage, or rate limiting trigger Google's bot-detection systems. MCP Scraper's API handles the anti-bot layer on the infrastructure side — the caller passes a keyword and receives structured PAA output; the detection friction never reaches the application layer. This is one of the most underestimated friction points in programmatic PAA collection: teams that build their own scrapers spend disproportionate engineering time on detection evasion rather than on the content strategy that the data enables.
Google monitors search behavior continuously to update PAA questions — session patterns, query sequences, click data, and location signals all feed the PAA algorithm in real time. This is why the same keyword returns different PAA questions depending on location, language, device, and time of day. It also explains why a static PAA dataset goes stale: the questions Google surfaces this week may differ meaningfully from last month's harvest. Recurring collection is the correct workflow for any live content operation. The monitoring is a feature, not a surveillance concern — it means PAA is a continuously refreshed intent signal, and the teams harvesting it regularly have a permanently updated editorial dataset that teams relying on one-time research do not.
Generate your PAA API request Keyword Max questions
## Stop copying questions from a SERP accordion. MCP Scraper delivers structured PAA trees via API — one call, any keyword, directly into your pipeline.
MCP Scraper is the PAA harvesting API for developers and SEOs who need more than 4 visible questions. Extract hundreds of People Also Ask questions from any query via REST or MCP.
Start free →
---
## Vibe Coding: The Complete Honest Guide
Canonical URL: https://mcpscraper.dev/blog/vibe-coding/
Published: 2026-05-24T00:00:00.000Z
Modified: 2026-05-24T00:00:00.000Z
What vibe coding actually is, which free tools work, whether you can get hired, and the data layer no tutorial mentions — 30 questions answered without the hype.
01
## What Is Vibe Coding?
The definition everyone links to, the origin story most posts get half-wrong, and the uncomfortable truth no one else in the top results will say.
Origin story
### "The hottest new programming language is English."
Andrej Karpathy said that in 2023. On February 2, 2025, he named the practice: vibe coding. The tweet reached 4.5 million views in days. Merriam-Webster added the term on March 8, 2025. Collins named it Word of the Year on November 6, 2025. The definition matters because everyone is now selling their own version of it.
Not exactly. In Karpathy's original framing, vibe coding is a specific mode: you describe what you want, you accept the code without reading it, and you treat bugs as a vibe to ride rather than a problem to debug. Merriam-Webster's listing makes the same point — coders don't need to understand how the code works and must accept that bugs will be present. That is narrower than "AI-assisted development," where you still review, accept, or reject every suggestion the model makes. Most products marketed as "vibe coding" today — Cursor, Copilot, Windsurf — are actually closer to AI-assisted development. The distinction matters because the risk profile is completely different the moment you start reading the output.
For prototypes, no. For anything you have to maintain, yes. The first working version of a tool — a price tracker, a Slack bot, a small dashboard — comes out of a vibe coding session in under an hour. The difficulty curve spikes the moment you try to extend it, debug a regression, or scale it past the original prompt. According to recent surveys, 66% of developers report spending more time fixing "almost-right" AI code than they save generating it. That gap is not in the tutorials. The skill that becomes hard is not writing code — it is reading code you didn't write, figuring out which AI suggestion to trust, and knowing when to throw the prototype away and rebuild it properly.
Yes — but not the skill most people expect. The transferable skill is prompt precision: describing system behavior clearly enough that the model produces the right thing on the first try. Add to that systems thinking (understanding how parts of an app talk to each other), and the judgment to spot when AI output is wrong before it ships. None of those require knowing syntax. All of them improve with practice. Vibe coders who succeed treat prompting as engineering — they iterate on prompts the way developers iterate on code, with versioned specs and explicit edge cases. Vibe coders who fail treat prompting as wishful thinking and re-prompt with the same vague description hoping for a better outcome.
For personal tools and throwaway prototypes — yes. For anything with real users, the practical floor is higher than the marketing suggests. The clearest data point: 25% of Y Combinator's W25 cohort is running codebases that are almost entirely AI-generated, but every one of those teams has a technical founder who understands what the AI is producing. The pattern in successful vibe-coded products is not "no engineering knowledge" — it is "engineering judgment without the syntax overhead." If you have never thought about how data flows through a system, you can still ship a working prototype. You will struggle the first time it breaks in front of a real user, and that moment arrives faster than most tutorials let on.
AI generates code that looks correct and isn't. The output reads cleanly, runs locally, and passes a casual review. It also reportedly contains SQL injection paths, leaked API keys in client-side bundles, overly permissive CORS configurations, and authentication logic that fails silently on edge cases. According to recent surveys, trust in AI code accuracy fell from 40% to 29% over the last year — not because the models got worse, but because more developers spent enough time with the output to see what it actually does. The "lower technical barrier" framing is honest for Day 0. It is actively misleading for Day 1 and beyond, when the cost of not understanding your own code starts showing up in production.
02
## Vibe Coding Tools.
Seven tools ranked honestly — including which ones are free, which are worth paying for, and the one question the tool comparison tables never answer.
Tool warning
### No single tool handles Day 0 and Day 1+.
Every tool is Day 0 optimized. None owns Day 1+. The emerging pattern: tools that let you build fast have weak maintenance stories. The moment you need to debug, audit, or extend AI-generated code, you're on your own. Pick your tool knowing this gap exists — and budget separately for the data, deployment, and review layers that none of them include.
Bolt.new and Replit are the two clearest entry points for non-developers. Both run entirely in the browser, both deploy a working app in one session, both require zero local setup. Bolt.new leans further toward "type what you want, see it run." Replit has a stronger long-term workspace because the project persists with files you can edit later. For developers who already have a code editor and want AI inside it, Cursor (2M+ users, $2B ARR) and Windsurf (1M+ active users) are the strongest options. The honest split: pick browser-based if you have never installed VS Code; pick Cursor or Windsurf if you have.
Yes. A definitive free-tier map. Bolt.new offers a free plan with daily token limits — enough to ship a small project, not enough to iterate heavily. Replit's free tier supports small public projects and runs in the browser. Aider is fully open-source and free, runs locally against any LLM you connect. Continue.dev is a free VS Code extension. Claude.ai and ChatGPT both offer free-tier chat that can generate complete code you paste into a runner. GitHub Copilot has a free tier for individuals. Cursor has a free tier with limited completions. The only thing that is not free across all of these: heavy daily usage. Every product gates volume, not access.
Claude and the GPT family are the two strongest code-generation models. For IDE-integrated use, two products dominate: GitHub Copilot leads on raw scale (20M total users, 4.7M paid subscribers, reportedly 42% of the AI coding assistant market) and Claude Code leads on satisfaction (91% CSAT in recent surveys, the highest of any AI coding tool measured). Developers using Copilot reportedly complete tasks 55% faster, with PR time dropping from 9.6 days to 2.4 days. The pragmatic answer: use Copilot if you live in VS Code and want the largest ecosystem; use Claude Code if you want the model most developers say produces the fewest "almost-right" answers.
For autonomous multi-step tasks, the leaders are Cursor's Composer, Windsurf's Cascade, and Claude Code. Cascade handles the most aggressive agentic workflows out of the box — multi-file refactors, end-to-end feature builds — and Windsurf was acquired by Cognition in December 2025 for reportedly ~$250M, which consolidated agentic capability under one roof. Claude Code is the highest-satisfaction agentic tool in developer surveys. The honest tradeoff: more autonomy means less review, which means more time fixing surprises later. Pick the level of autonomy you actually want to audit.
Yes, but ChatGPT alone is a copy-paste workflow. You describe what you want, ChatGPT generates the code, you paste it into a runner — Replit, your local terminal, a CodeSandbox tab. That works, and it is genuinely free at the entry tier. The friction is everything between paste and run: you don't get inline edits, you don't get file-level context, and you re-paste the whole project every time you want a change. A better free path is ChatGPT plus Replit (ChatGPT writes, Replit runs and persists) or ChatGPT inside an IDE through a plugin. ChatGPT is a viable free-tier route into vibe coding. It is not the best long-term home for a real project.
"App" depends on the device. On desktop: Cursor is the most powerful for developers, Bolt.new is the fastest for non-coders, and Replit is the most balanced if you want both browser convenience and a real workspace. On mobile: Replit's iOS app is the only environment that supports full project builds from a phone. Claude.ai and ChatGPT also run in mobile browsers and can generate code you deploy elsewhere, but neither is a complete vibe coding environment on its own. The next section covers iPhone-specific workflows in detail — most posts skip this entirely, even though the question shows up clearly in search.
03
## How to Start Vibe Coding.
A step-by-step path for non-developers, the one thing every tutorial skips (getting real data into your tool), and the iPhone question every other guide ignores.
Critical gap
### The prototype always works. The live version needs a data layer.
Prompting AI to build a tool is 30 minutes. Getting it live data is where most projects die. Every useful vibe-coded tool eventually needs to read from the real web. Price trackers need prices. Research tools need pages. Lead generators need business data. That's where MCP Scraper enters the workflow.
Three steps. In this order. First, pick a browser-based tool — Bolt.new or Replit — so you skip every "install this, configure that" trap that kills momentum on day one. Second, describe one specific thing you want to build, not a general app idea. "A tool that emails me when the price of these three Amazon products drops" beats "an e-commerce price tracker" because the model can build the first one in one pass. Third, test the output immediately and iterate with precise corrections — name the file, the function, and the exact behavior you want changed. The most common beginner failure is prompting vaguely and then re-prompting with more vagueness, hoping the model figures it out.
Yes for systems thinking. No for syntax. Vibe coding teaches you to think in terms of inputs, outputs, state, and failure modes — the conceptual layer that makes a developer effective. It teaches debugging logic, because you spend real time reading errors and asking the model what they mean. It teaches prompt precision, which transfers to spec-writing in any technical role. What it does not teach is syntactic fluency, language-specific idioms, or low-level architecture decisions. If your goal is to be hired as a traditional software engineer at a company that interviews on syntax, vibe coding is an accelerator for concepts and a poor substitute for fundamentals. If your goal is to ship products, the concepts matter more.
Yes, with real limitations. Replit has a functional iOS app that supports full project builds, file editing, and deployment from your phone. Claude.ai and ChatGPT both run in Safari and can generate complete code you paste into Replit or another runner. Bolt.new is browser-accessible on mobile, though the desktop layout is the supported experience. No current iOS tool matches the desktop IDE experience for serious projects. For prototyping a small tool, drafting a Slack bot, or sketching the first version of an app idea, your iPhone is a viable vibe coding environment — and it is the only environment most travelers have on day one of an idea.
No. Apple's App Store Review Guidelines do not categorically ban AI-generated code. What they ban — and have always banned — are thin wrappers around web content, spam apps with no original functionality, and apps that violate content or privacy policies. None of those rules are AI-specific. The accountability standard is unchanged: the developer is responsible for the app's behavior, regardless of how the code was produced. A vibe-coded native app that genuinely does something useful for the user, handles data responsibly, and meets the same review bar as any other app will pass review. A vibe-coded app that wraps a website in a webview and adds nothing will not — and would not have passed review in 2018 either.
For prototyping and personal tools — unambiguously yes. For production at scale — only with engineering oversight. The data supports both halves. 84% of developers use or plan to use AI coding tools, with average savings of 3.6 hours per week. 25% of Y Combinator's W25 cohort runs nearly all-AI-generated codebases. At the same time, 66% of developers report spending more time fixing "almost-right" AI code than they save generating it, according to recent surveys. The honest read: vibe coding is excellent for the 80% of ideas that never needed production-grade code in the first place, and it is genuinely risky for the 20% that do. The skill is knowing which one you're building.
04
## The Real Limits.
Security vulnerabilities, the Day 0 vs. Day 1+ cliff, what happens when AI-generated code hits production — and how to protect yourself.
Industry stat
### 66% of developers reportedly spend more time fixing AI code than generating it.
This is not an argument against AI coding tools. It is an argument for using them with your eyes open. The productivity gains are real — if you know when to trust the output and when to audit it.
Most do not, by design. Karpathy's original framing is explicit: you give in to the vibes, you accept the code without reading it, you let the model handle bugs by reprompting rather than debugging. Merriam-Webster's definition repeats the same idea — practitioners don't need to understand how the code works and must accept bugs will be present. That is fine for personal tools you can throw away. It is a serious liability for anything deployed to real users: you cannot debug a system you do not understand, you cannot catch security issues you never look for, and you cannot tell a user with confidence what your app actually does with their data. The Day 0 advantage becomes the Day 1+ liability.
AI-generated code commonly introduces SQL injection vulnerabilities, insecure API key handling, overly permissive CORS configurations, and authentication logic that fails silently on edge cases. None of these are visible to a non-developer reviewing the output, because the code looks correct. The mitigation is not "review your code more carefully" — that asks vibe coders to do exactly what they came here not to do. The mitigation is an automated security scanner. Snyk, GitHub Advanced Security, and Semgrep each run continuously and flag the common AI-generated mistakes before deploy. Pair every vibe coding session with a scanner that runs on commit, and you eliminate the most common production-breaking class of mistake without learning to read every line.
Three hard cases. First, systems handling personal data under GDPR, HIPAA, PCI-DSS, or similar — AI-generated code needs auditing you cannot DIY, and the regulatory penalty for getting it wrong is higher than the time you saved. Second, financial transaction logic — silent rounding errors, race conditions, and authorization gaps compound quickly and quietly. Third, anything you need to maintain for more than 12 months without a developer — AI-generated codebases become unmaintainable faster than hand-written code because the structure was never designed for change. Vibe code freely when the cost of being wrong is small. Bring in engineering when the cost of being wrong is asymmetric.
Every vibe coding tool is optimized for the first working build. None of them is optimized for what comes after. Day 1+ problems are predictable: adding a second feature without breaking the first, debugging a regression you cannot trace, scaling to enough users that the original architecture cracks, and integrating third-party APIs whose contracts change. The tools do not advertise this gap because Day 0 demos sell better than maintenance demos. One developer-practitioner survey concluded that no single tool today can build and maintain an entire application end-to-end. Plan for the Day 1+ moment before it arrives. Pick a tool with file-level access, version control, and an escape hatch into real code review.
Yes — with documented examples. One builder shipped more than ten vibe-coded apps that were used reportedly close to a million times in total before scaling and maintenance pressure forced a pause. Kevin Roose's LunchBox Buddy — a fridge-photo-to-meal-suggestion tool — was cited in the New York Times as an early vibe coding demo. Refetch, an open-source Hacker News alternative, was reportedly built in 15 hours of vibe coding on Appwrite Cloud. The pattern across these cases is consistent: vibe-coded apps scale to early traction with no problem, and the crisis arrives when traffic, data volume, or feature scope exceeds what the original AI-generated architecture was built for. That crisis is solvable. It just doesn't solve itself.
05
## Career & Hiring.
Six questions no competitor will answer — whether vibe coding is a real job, what it pays, and how to position it when you're applying.
Hiring signal
### The fastest-growing startups have already decided vibe coding is production-ready.
25% of Y Combinator's current cohort runs codebases that are almost entirely AI-generated. IBM cites the stat. Google ignores it. Medium skips it. None asks the obvious next question: what does that mean for the person reading this article? The job market is catching up.
It is becoming one — fastest at startups, slowest at large enterprises. Early-stage companies increasingly list "AI-assisted developer," "AI product builder," "prompt engineer," and "no-code/AI builder" roles. Freelance platforms like Upwork and Fiverr have active vibe coding service categories with steady project volume. At enterprise scale, formal "vibe coder" titles are still rare — but the practice is embedded in 18% of developers' day-to-day work according to JetBrains' January 2026 survey, and at the YC startups where 25% of codebases are nearly all AI-generated, it is the default daily practice. The title is lagging the work by roughly 18 months. The work is already mainstream.
Early-stage startups and solo-founder companies actively do. Common titles include "growth engineer," "founding engineer," "AI product builder," and "technical founder in residence." The hiring signal is clearest in YC-backed companies and Series A startups where shipping speed matters more than code purity. Traditional enterprise software companies have been slower — their hiring processes are designed to test syntax and system-design fundamentals, which vibe coders often have not formally studied. The market direction is consistent with broader adoption: the AI coding tools market reportedly reached $7.37 billion in 2025, and 84% of developers use or plan to use AI tools. The companies hiring fastest are the ones building fastest.
If you can show working products — yes. The portfolio matters more than the title. Demonstrating that you shipped a functional tool used by real people is more compelling to early-stage hiring managers than a CS degree or a coding bootcamp certificate. A live URL with real users beats a GitHub repo with no traction. The friction point is larger companies whose engineering interviews are designed around whiteboard syntax problems vibe coders have not drilled on. The pragmatic path: build five shippable tools, get real users for at least one, document what you built and what you learned, and apply to companies whose hiring is portfolio-driven rather than interview-driven. The first job is the hardest. After the first job, the portfolio compounds.
Ranges vary by context. Approximate market signal as of 2026: Freelance project rates on Upwork and Fiverr for AI-built tools reportedly range from $500 to $5,000 per project, depending on scope and the client's budget. Full-time "AI-assisted developer," "AI product builder," and "founding engineer" roles at startups reportedly range from $80K to $140K base depending on seniority and location, with equity on top. Indie hackers shipping revenue-generating vibe-coded apps have publicly reported product revenue from $1K to $20K per month, with outliers higher. The ceiling scales with what you build, not what you know. Salaried roles cap your upside; products do not. Treat these as ballparks — no single survey aggregates them yet, and the market is moving monthly.
It depends on which job market you are targeting. In the startup and indie developer ecosystem — yes, building with AI is a marketable practice with paying roles and growing demand. In regulated industries (healthcare, finance, defense) and large enterprise environments — not yet as a standalone role, because compliance and code-audit requirements still demand engineers who can read every line. The trajectory is clearly toward normalization: AI reportedly writes about 41% of all new code today, 84% of developers are using or planning to use AI tools, and 25% of YC's current cohort runs nearly-all-AI-generated codebases. The current state is early but real. The forward curve points toward "yes" being the default answer within two to three years.
06
## The Future of Coding.
Whether AI will replace coders, what the realistic 2026–2040 arc looks like, and the one skill that becomes more valuable as AI writes more code.
Key take
### AI replaces code-writing. It doesn't replace problem-solving.
The developers who will struggle are those whose value is in typing code fast. The developers who will thrive are those whose value is in knowing what to build, how systems should behave, and when AI output is wrong. Vibe coding is the fastest way to find out which one you are.
Rote code-writing is already being replaced. AI reportedly writes about 41% of all code today, and 84% of developers use or plan to use AI coding tools. The role-level effect is more specific than "coders are obsolete": developers who specialize in syntax and straightforward implementation are most exposed; developers who specialize in architecture, system design, and problem framing are least exposed. The practice of writing code is being automated. The judgment of what to build, why to build it, and how to know whether it works is not — and there is no current evidence that it will be soon. "Coder" is becoming a smaller part of "software developer." The other parts are growing.
By 2040, AI will likely generate the majority of code by volume. What survives — and what the labor market will pay for — is the meta-skill: defining problems precisely, evaluating AI output critically, and directing systems toward intended outcomes. The vibe coder of 2026 who develops those meta-skills is better positioned than the traditional developer who ignores them. The career risk over the next 15 years is not AI itself. It is the choice not to adapt to AI. The 25% YC cohort statistic is the leading indicator: the fastest-growing companies are already operating at the model that the rest of the market will reach. Plan accordingly.
Prompt precision. The ability to describe complex system behavior clearly enough that AI produces the right output on the first try is the emerging premium skill. Closely paired with it: the ability to audit AI output for correctness, security, and architectural soundness — not by reading every line, but by knowing which questions to ask and which automated checks to run. Both are learnable by non-developers. Neither requires fluency in any programming language. The developers who treat prompting as engineering — versioned, specified, tested — are already pulling ahead of the developers who treat it as a chat. That gap will widen.
Three things — and the middle one is where most vibe coders stall. First, a deployment target: Vercel, Replit, Railway, Fly.io. Second, real data access — every useful live tool eventually needs to read from the web, and writing custom scrapers, handling JavaScript-rendered pages, and maintaining selectors as sites change is the wall most prototypes hit. Third, a feedback loop with actual users. The data access layer is the most underestimated step in the entire vibe coding workflow. MCP Scraper is the data layer vibe coders reach for when the prototype needs to start consuming real-world inputs — SERP results, People Also Ask trees, page extraction, YouTube transcripts — without writing and maintaining the scraping code themselves.
## Your vibe-coded app needs real data.
MCP Scraper gives your AI-generated tools the live web data they need — SERP results, People Also Ask harvests, page extraction, and structured scraping — without writing a single line of custom scraping logic.
Start free →
---
## What Is an MCP? The Honest Developer
Canonical URL: https://mcpscraper.dev/blog/what-is-an-mcp/
Published: 2026-05-24T00:00:00.000Z
Modified: 2026-05-24T00:00:00.000Z
MCP explained for developers who need to decide — not just understand. Which platforms adopted it, when to skip it, and how it compares to REST, Zapier, and Copilot.
01
## MCP Defined
What MCP actually is, what it does, and the architectural distinction every explainer skips.
Quick take
### MCP is not USB-C.
USB-C is a hardware connector. MCP is an architectural decision — a protocol that determines whether your AI agent can discover and call tools at runtime or must be hardcoded by a developer. The analogy hides the trade-off. This section names it.
MCP — Model Context Protocol — is an open standard launched by Anthropic on November 25, 2024, that gives AI agents a single, standardized interface to connect with external tools, data sources, and workflows. Before MCP, every AI model and every external tool required a custom integration written by a developer. MCP eliminates that custom work by defining a shared communication contract that any agent and any tool can implement once and then use interchangeably. An agent calling GitHub, Postgres, and Slack no longer needs three bespoke connectors — it needs one MCP client. The practical implication most explainers miss: MCP is not primarily a developer convenience — it's what makes AI agents autonomous enough to run without a human in the loop on every tool call.
MCP enables AI agents to discover, invoke, and receive results from external tools at runtime — without a developer pre-configuring every possible tool call. The mechanism is a standard called tools/list : an agent sends this request to any MCP server and gets back a live manifest of every capability that server exposes, including names, descriptions, and input schemas. The agent then selects the right tool, calls it, and receives structured output — all without leaving its session. Connecting an agent to a CRM, a code repo, and a web scraper used to mean three separate integrations; MCP makes them all callable through the same protocol. The deeper point: MCP doesn't just save integration work — it makes tool use something the agent decides at runtime rather than something a developer hardcodes at build time.
MCP is a shared language that any AI agent and any tool can both speak . Once a tool publishes an MCP server, every MCP-compatible agent — Claude, ChatGPT, Cursor, GitHub Copilot — can call it without a custom connector. The analogy that actually holds: imagine if every REST API automatically understood every other API's auth, parameter format, and response schema without any glue code. That's what MCP does for AI agents. A Postgres database, a Slack workspace, and a web data service all become callable through the same interface once they expose an MCP server. The distinction that matters in practice: "simple" doesn't mean effortless — the tool still has to implement the MCP server; MCP just ensures that implementation only has to happen once.
MCP is neither — it's a protocol , which means a specification for how two systems communicate, not software you install or a framework you build on top of. Tools implement MCP (a Postgres connector that speaks MCP is a tool). Frameworks integrate MCP clients (LangChain, AutoGen). MCP itself is the rulebook those implementations follow — specifically, a JSON-RPC 2.0 message format plus a defined session lifecycle. IBM's documentation makes this distinction explicitly: MCP is not an agent framework. The practical consequence: asking "which MCP should I choose?" is like asking "which HTTP should I use?" — the protocol is the same; your choice is which server or client library implements it.
MCP solves the N×M integration problem : without it, connecting N AI models to M external tools produces N×M custom integrations, each built and maintained separately. MCP collapses this to M+N — implement the protocol once on each side and every combination works. The secondary problems it solves flow from the same root: inconsistent auth patterns across integrations, brittle hardcoded tool calls that break when APIs change, and the inability for AI agents to discover new tools at runtime. An enterprise with 10 AI models and 50 internal tools faces 500 custom integrations without MCP and 60 protocol implementations with it. What no explainer says plainly: MCP doesn't reduce the number of tools you build — it reduces the number of connectors that break when either side changes.
Anthropic is the AI safety company that created Claude and launched MCP on November 25, 2024. In December 2025, Anthropic donated MCP governance to the Agentic AI Foundation under the Linux Foundation — a move that made MCP formally vendor-neutral and accelerated adoption by removing the perception that the protocol was an Anthropic-controlled standard. Anthropic was founded in 2021 by former OpenAI researchers, including Dario Amodei and Daniela Amodei. Its two primary contributions to AI infrastructure are Claude (a family of large language models) and MCP (the protocol this post covers). The governance transfer is the detail most explainers skip: Anthropic no longer controls MCP — the Linux Foundation body does, which is why OpenAI, Microsoft, and Google were willing to adopt it.
02
## MCP vs Everything
MCP vs REST, HTTP, Zapier, Copilot, and LLMs — the comparisons that actually determine whether MCP belongs in your stack.
Key distinction
### REST serves developers. MCP serves AI agents.
That one sentence determines whether MCP belongs in your architecture. If the caller is a developer writing code, use REST. If the caller is an agent making runtime decisions, MCP earns its overhead. The mistake is treating them as competing choices rather than different interface layers.
REST APIs serve developers; MCP serves AI agents — and that distinction determines which belongs in your system. A REST API is a stateless HTTP endpoint with static documentation a human reads and then hardcodes calls against. MCP is JSON-RPC 2.0 over a persistent session, with a live tool manifest the agent reads at runtime and uses to decide what to call. The critical difference: with REST, a developer writes the integration once and it breaks when the API changes; with MCP, the agent re-discovers the tool manifest on every session and adapts. MCP doesn't replace REST — MCP servers use REST internally. What changes is the interface layer above: REST is for humans integrating systems; MCP is for agents choosing tools.
Use MCP instead of REST when the consumer of the API is an AI agent making runtime decisions — not a developer writing hardcoded calls. MCP's tools/list endpoint lets an agent discover what a server can do without any human-written glue code . With REST, someone has to read the OpenAPI spec and write the integration; with MCP, the agent reads the live capability manifest and writes the call itself. The answer changes if you control both ends: if you own the API and the code calling it, REST is simpler and faster. MCP earns its overhead when the caller is an autonomous agent that needs to self-direct across a changing tool landscape — the moment you want the agent to decide which tool to use, not just execute the one you told it to.
Raw HTTP has no standard for tool discovery, session state, or AI-native authentication — MCP adds all three on top of HTTP. An agent calling raw HTTP endpoints has to know the URL, method, parameters, and auth scheme in advance, hardcoded. An MCP server exposes a tools/list manifest so the agent discovers capabilities dynamically, maintains state across a session, and uses a standardized OAuth 2.1 flow for auth rather than each API's bespoke scheme. The practical failure mode of raw HTTP at scale: when the tool landscape changes — a new endpoint, a deprecated parameter — every hardcoded HTTP call breaks silently; MCP's session-level capability manifest surfaces changes the agent can adapt to. Building on raw HTTP for agents is not wrong at toy scale — it fails at production scale when the number of tools grows past what any developer can maintain manually.
MCP and Zapier solve adjacent problems with different audiences. Zapier automates workflows between apps for non-technical users; MCP is a protocol for AI agents to call tools programmatically . Zapier's model is: a human configures a trigger-and-action workflow once; Zapier runs it. MCP's model is: an AI agent discovers available tools at runtime and decides which ones to call. The two are not mutually exclusive — Zapier built MCP support on top of its library of 9,000+ apps and 30,000+ actions, meaning an AI agent with an MCP client can now reach every Zapier-connected app without the human workflow-configuration step. The practitioner nuance: Zapier MCP is useful when you want AI agent access to Zapier's app coverage without building individual MCP servers for each app.
GitHub Copilot is an AI coding assistant that now operates as an MCP client — MCP is the protocol Copilot uses to reach external tools, not a competitor to Copilot. The relationship: Copilot is software running in VS Code or a browser; when Copilot needs to call an external tool (a Jira ticket, a GitHub repo, a web search), it does so through MCP. Before MCP, Copilot's tool integrations were custom connectors maintained by Microsoft. With MCP, any tool that publishes an MCP server becomes callable by Copilot without Microsoft writing a dedicated integration. The distinction developers miss: evaluating "MCP vs. Copilot" is a category error — Copilot is an adopter of MCP, not an alternative to it.
An LLM is the reasoning engine — the model that reads input, generates text, and makes decisions. MCP is the protocol that gives that engine hands. Without MCP (or a comparable integration layer), an LLM can only work with what's in its context window — text and pre-loaded data. With MCP, the LLM can call tools at runtime: retrieve a live database record, execute a search query, write a file, trigger a workflow. Claude 3.5 Sonnet reasoning about a customer support ticket is an LLM at work; Claude calling a CRM to retrieve the customer's history mid-conversation is MCP at work. The frame that matters: LLMs decide; MCP acts. A sophisticated AI agent needs both.
MCP uses JSON-RPC 2.0 as its message format, but calling it "just JSON" misses the protocol. JSON-RPC 2.0 defines the envelope — request IDs, method names, parameters, error codes. MCP adds on top of that a defined session lifecycle: initialization handshake → capability negotiation → tool discovery → tool calls → termination. JSON alone specifies none of that structure. The distinction matters when debugging: a malformed MCP session isn't a JSON syntax error — it's a lifecycle state error, which requires understanding the protocol's state machine, not just validating JSON. The practitioner test: if your MCP server returns valid JSON but ignores the initialization handshake, every MCP client will reject it — not because the JSON is wrong, but because the protocol contract is broken.
03
## MCP Adoption — Who Actually Uses It
Which platforms adopted MCP, which haven't, and the one misconception that sends most developers to the wrong conclusion.
Highest-value misconception
### MCP is not only for Claude.
MCP has 300+ clients as of March 2026 — including ChatGPT, GitHub Copilot, VS Code, Cursor, and Google Gemini. Anthropic created it. The Linux Foundation now governs it. Write one MCP server. Every major AI platform can call it.
No — and this is the highest-value misconception in the MCP ecosystem. MCP has 300+ clients as of March 2026 , including ChatGPT, GitHub Copilot, VS Code, Cursor, Windsurf, AWS Bedrock, Google Gemini, and JetBrains IDEs. Anthropic created MCP but donated its governance to the Agentic AI Foundation under the Linux Foundation in December 2025, making it a vendor-neutral standard no single company controls. OpenAI formally adopted MCP in March 2025 — four months after Anthropic launched it. The practical implication for developers: an MCP server you build today is reachable by Claude, ChatGPT, and GitHub Copilot without any modification — write the server once, serve every major agent platform.
Yes — OpenAI formally adopted MCP in March 2025 and added MCP support to ChatGPT apps in September 2025. OpenAI's adoption removed the last credible argument that MCP was a Claude-exclusive or Anthropic-controlled standard. When OpenAI adopted MCP, the protocol had an estimated 22 million monthly SDK downloads; by March 2026 that figure reached 97 million. ChatGPT is now one of more than 300 MCP clients — meaning any MCP server you build is natively callable from ChatGPT without any OpenAI-specific integration work. The sequence developers should know: Anthropic launched → OpenAI adopted → Microsoft integrated → Google followed — MCP's cross-vendor adoption happened in under 18 months.
Yes — Microsoft integrated MCP into GitHub Copilot, Visual Studio Code, and Copilot Studio . The GitHub Copilot extension in VS Code is among the most widely used MCP clients in the developer tooling ecosystem. Microsoft's adoption matters structurally: it brought MCP into enterprise environments at scale, since VS Code and GitHub Copilot are standard tooling in most engineering organizations. The consequence for MCP server builders: publishing an MCP server means your tool is callable from VS Code's AI features — the IDE that runs on more developer machines than any other. Microsoft's integration also means MCP is no longer a decision individual developers make; it's a platform decision that enterprise engineering teams inherit from their tooling.
Apple has not made a public MCP announcement as of May 2026. The honest answer is: unknown, but structurally likely. MCP clients that run on Apple platforms — Claude Desktop, VS Code, Cursor — are in wide use on macOS. If Apple builds agentic AI features into iOS or macOS, adopting MCP would give it instant interoperability with every existing MCP server ecosystem rather than requiring Apple to build a proprietary tool integration standard from scratch. The precedent: every other major AI platform that initially appeared absent from MCP (OpenAI, Microsoft, Google) has since formally adopted it. The practitioner read: Apple's silence is not a rejection — it's the gap between enterprise announcement cycles and protocol adoption reality.
Yes — Zapier MCP is included on all Zapier plans, including the Free tier , at no additional cost. There is no separate product SKU. The only cost is task consumption: each MCP tool call uses 2 tasks from your existing Zapier task quota. A developer on Zapier's free plan can connect an AI agent to Zapier's 9,000+ app library and 30,000+ actions today, using their existing task allocation. The nuance that changes the math: "free" means no incremental charge, not zero cost — if an agent makes 500 MCP tool calls in a month, that consumes 1,000 tasks from your quota. High-volume agent workflows will exhaust free-tier quotas quickly and require a paid plan.
04
## When MCP Breaks Down
When not to use MCP, why production projects stall, and the honest comparison to adjacent tools.
Practitioner test
### MCP has no native auth.
The spec recommends OAuth 2.1 with PKCE. Your MCP server only has it if you built it. Every production MCP project that stalled did so at auth, not at the protocol itself.
Skip MCP when your system is developer-to-API rather than agent-to-tool . If a human developer is writing the integration code, REST is simpler and adds no session-management overhead. Skip MCP when you control both ends of the integration and don't need runtime discovery — if you own the calling code and the tool, you already know what the tool does; the tools/list handshake is unnecessary overhead. Skip MCP when latency is the primary constraint — persistent sessions add round-trip initialization costs that stateless REST calls don't. Skip MCP when your AI use case is inference-only: if the model generates text without calling any external system, MCP adds complexity with zero benefit. The practitioner test: if a human could write the integration code once and it would never need to change, use REST.
The most common friction points are auth complexity, debugging difficulty, and server quality variance. MCP has no native authentication — developers must implement OAuth 2.1 with PKCE themselves, and the gap between "runs locally" and "ships securely to production" is where most MCP projects stall. Debugging is harder than REST because persistent sessions have lifecycle state: a broken MCP connection isn't a failed HTTP request — it's a state machine that failed at initialization, capability negotiation, or mid-session, and the error may not surface clearly. The 10,000+ public MCP servers have wildly inconsistent quality — some are maintained production services; many are experimental projects with no uptime guarantees. "Moving away" overstates it: developers who understand MCP's limits ship successfully; the ones who expected plug-and-play get surprised by the operational requirements.
A2A — Google's Agent-to-Agent protocol — is not dead, but it has not achieved the ecosystem density MCP has. MCP and A2A address different layers : MCP handles tool access (an agent calling an external capability); A2A handles agent coordination (one agent delegating a task to another agent). They are complementary, not competing. The adoption gap is real: MCP has 97 million monthly SDK downloads and 300+ clients as of March 2026; A2A's ecosystem is smaller by every public measure. The honest framing: A2A is the correct protocol for multi-agent orchestration problems; MCP is the correct protocol for tool-calling problems. A developer who needs both can use both — and the most sophisticated agent architectures will.
No — MCP wraps APIs rather than replacing them . MCP servers use REST APIs internally; they expose MCP above and call REST below. The correct model: REST remains the implementation layer; MCP becomes the interface layer that AI agents interact with. This isn't a philosophical position — it's how production MCP servers are built. An MCP server for Stripe doesn't replace Stripe's REST API; it wraps it, adding the tools/list manifest and session management that AI agents expect. The question developers should ask instead: not "will MCP replace REST?" but "at which layer does MCP belong in my stack?" — the answer is always above your existing APIs, never instead of them.
Copilot critics object to Microsoft's pricing model, data training practices, and the perception that Copilot is a productivity layer rather than a reasoning upgrade . Common complaints include the cost per seat relative to perceived productivity gains, concerns about code written in Copilot being used to train future models, and the view that Copilot autocompletes rather than reasons. These criticisms are entirely separate from MCP — MCP is the protocol Copilot uses to reach external tools; it doesn't change Copilot's pricing, training data policies, or reasoning depth. The relevant clarification for developers evaluating both: being against Copilot doesn't mean avoiding MCP — every other major AI platform (Claude, ChatGPT, Cursor) also uses MCP and has none of Copilot's specific controversies.
05
## MCP Architecture & Security
Transport layers, encryption, auth, and the gap between what MCP promises and what your server actually ships.
Security gap
### MCP won't refuse an HTTP connection.
The spec recommends HTTPS. Enforcement is the developer's job. Most MCP tutorials run over HTTP for simplicity — developers copy that configuration to production and ship an insecure server without any warning from the protocol. TLS is your responsibility, not MCP's.
MCP supports two transport layers: stdio for local in-process communication and HTTP with Server-Sent Events (SSE) for remote connections . Local MCP servers — the kind that run on a developer's machine alongside Claude Desktop — use stdio, which is faster and simpler because the agent and server are in the same process space. Remote production MCP servers use HTTP/SSE, which enables cross-network communication but requires TLS since MCP has no native encryption layer. Most production MCP servers use the HTTP transport — it's what makes an MCP server callable from any agent on any machine. The choice isn't either-or: a single MCP server implementation can support both transports, but most developers building for production start with HTTP/SSE.
MCP supports both, but the spec explicitly recommends HTTPS for any remote server — and running an MCP server over plain HTTP in production is a security vulnerability, not a configuration choice. MCP does not natively enforce encryption; TLS must be configured by the developer. The risk is concrete: MCP sessions carry tool call parameters and responses over a persistent connection — plain HTTP exposes that entire session to interception. Local development over localhost HTTP is acceptable (the connection doesn't leave the machine); any server exposed over a network must use HTTPS. The gap most teams hit: MCP tutorials run over HTTP for simplicity; developers copy that configuration to production and ship an insecure server without realizing the protocol never warned them.
MCP standardizes OAuth 2.1 with PKCE for authentication in remote server connections — but this is not built into the base protocol. OAuth support was added to the MCP spec after initial launch, when real-world adoption revealed auth as the most common production gap. Implementing it requires developers to configure an OAuth 2.1 server, handle PKCE flows, and manage token refresh — none of which MCP handles automatically. Local MCP servers running over stdio typically require no auth because they run in a trusted local environment. Remote servers require auth, and OAuth 2.1 with PKCE is the spec-recommended approach. The practitioner reality: "MCP supports OAuth" means MCP defines how OAuth should work in its context — it doesn't mean your MCP server has OAuth until you build it.
An MCP server looks like an API from the outside but differs in three structural ways. First, it exposes a standard capabilities manifest via tools/list — a traditional API has static docs; an MCP server has a live, machine-readable manifest the agent queries at runtime. Second, it maintains session state across multiple calls within a connection — REST APIs are stateless by design; MCP sessions are stateful. Third, it uses JSON-RPC 2.0 rather than REST conventions — request/response patterns, error codes, and method naming all follow JSON-RPC semantics, not HTTP verb conventions. Calling an MCP server and calling a REST API look superficially similar from a network perspective; they're architecturally different contracts that break in different ways when misused.
06
## MCP Ecosystem & What's Next
Power Automate, Google's investment, and why MCP is a layer above APIs rather than a replacement for them.
Nothing has fully replaced Power Automate — it remains Microsoft's enterprise workflow product and continues to serve the structured, if-then automation use cases it was built for. What MCP and AI agents are taking from Power Automate is the dynamic, decision-driven tier of automation — tasks that require reasoning, not just routing. Power Automate routes data between systems based on rules a human writes; an MCP-connected agent can decide which tools to call, handle edge cases without pre-written rules, and adapt to inputs that a static workflow would reject. Routing a support ticket to the right queue is Power Automate's domain; reading the ticket, checking the customer's history, drafting a response, and escalating if needed is where MCP-connected agents outperform static workflow tools. The transition isn't replacement — it's a shift in which automation problems belong in which category.
Google has invested significantly in Anthropic across multiple rounds, but the exact ownership percentage is not publicly disclosed . Reports indicate Google invested $300 million in a 2023 funding round and participated in subsequent rounds. The precise ownership stake — including whether it is or was 14% — has not been confirmed in any public filing. What is confirmed: Google Cloud and Anthropic have a partnership that includes MCP integration into Google's Gemini models and Google Cloud services. The relevant fact for MCP evaluation: Google's investment in Anthropic did not prevent Google from independently adopting MCP — both Google Gemini and Google Cloud services are listed among MCP clients, and adoption was driven by the protocol's open governance under the Linux Foundation, not by equity relationships.
MCP is best understood as a layer above APIs, not a replacement for them . Saying MCP is basically an API is like saying HTTP is basically a phone call — technically there's a connection, but the architectural purpose is different. Traditional APIs serve developers who know what they want to call and write the call in advance. MCP serves AI agents that discover what's available at runtime and decide what to call dynamically. The difference shows up at scale: an API breaks when you add a new endpoint that no existing code knows to call; an MCP server's tools/list response automatically surfaces the new capability to every connected agent on the next session. MCP Scraper is an example of what this makes possible — a web data tool built not for developers to integrate manually, but for AI agents to discover and call directly, the way MCP was designed to work.
## Build for the agent era. MCP Scraper is an MCP-native tool — extract PAA data the way AI agents actually work.
MCP Scraper gives AI agents the web data they need — PAA questions, SERP results, and page content via REST or MCP. Built for the agent-native stack.
Start free →
---
## When Not to Use an MCP: The Architectural Decision Guide
Canonical URL: https://mcpscraper.dev/blog/when-not-to-use-an-mcp/
Published: 2026-05-24T00:00:00.000Z
Modified: 2026-05-24T00:00:00.000Z
Not complexity—architecture. The three signals that disqualify MCP, the A2A and function-calling alternatives, and the protocol durability question for 2026.
01
## What MCP Actually Is.
Every article about MCP tells you it's a protocol that lets AI models call tools. That definition is technically accurate and practically useless — it skips the problem MCP was invented to solve, which is the only thing that tells you whether you need it at all.
MCP (Model Context Protocol) is an open standard that solves the N×M integration problem — the combinatorial explosion that happens when M AI models each need custom connectors to N external tools. Before MCP existed, connecting three AI models to ten tools required up to thirty custom integrations; MCP standardizes the interface so any compliant model can call any compliant server without custom work. The official description is "like a USB-C port for AI applications" — a single standardized connector that replaces a sprawl of proprietary cables. The current stable specification (2025-11-25) is built on JSON-RPC 2.0, defines three roles (Hosts, Clients, Servers), and is supported across Claude, ChatGPT, Visual Studio Code, and Cursor. The question to ask before adopting MCP is not "what is it" but "do I have an N×M problem worth solving at the protocol layer" — if you have one model and one tool, you don't.
MCP is the standardized language that lets an AI model ask an external tool to do something — and get a structured answer back — without either side needing to know how the other was built. Think of it as a universal remote control for AI agents: instead of each AI building its own custom remote for each device it wants to control, MCP gives every device a standard input jack and every remote a standard output plug. In practice, an MCP server exposes a list of "tools" (callable functions) with descriptions the AI model reads. The model decides which tool to call and passes structured arguments; the server executes the operation and returns a result. What makes this worth a protocol is that the model doesn't need to be rewritten when the tool changes, and the tool doesn't need to be rewritten when a new AI model is added. A practitioner who has shipped MCP integrations will tell you the simplification is real at scale — and essentially invisible for single-tool, single-model use cases.
MCP solves two structural problems that emerge when AI systems grow beyond a single model connected to a single tool: the N×M connector problem and the capability-discovery problem. The N×M connector problem is architectural: without a standard, every new AI model requires custom integration code for every tool it needs to call — the cost scales multiplicatively, not additively. The capability-discovery problem is subtler: before MCP, a model had to know at design time exactly what an external tool could do; with MCP, the server advertises its capabilities dynamically at session start, so the model can adapt to whatever tools are available. Both problems are irrelevant when you have one model and one tool with a stable interface — which is why "what problems does MCP solve" is also the correct frame for "when not to use MCP." If neither problem applies to your current system, the protocol layer adds overhead without payoff.
MCP manages the full lifecycle of a tool-calling session between an AI model and an external server: capability negotiation at connection, tool invocation during the session, and structured result delivery back to the model. The stateful session is MCP's defining feature — unlike a REST API call where each request is independent, an MCP session maintains context across multiple tool calls, so the model can use the output of one tool as the input to the next without the orchestration living inside the model itself. In concrete terms: when a Claude instance connects to an MCP server, the server first sends a list of available tools with descriptions. Claude reads those descriptions, decides which tool to call, sends a structured JSON-RPC request, and receives a structured result. The session stays open so Claude can call additional tools without re-authenticating or re-negotiating capabilities. For single-tool, single-call integrations, this session overhead is pure cost.
MCP is a protocol — not a tool, not a framework, and not a library. A protocol defines the rules for how two parties communicate; it does not prescribe how either party is implemented, which is what makes MCP portable across AI models and tool servers built in different languages and architectures. The practical consequence is that calling MCP a "framework" is a category error that leads to wrong architectural expectations: frameworks come with opinions about structure, abstractions, and project layout. MCP has none of those — it defines message formats, session lifecycle, and capability negotiation only. If you need a framework to build MCP clients or servers, you use an SDK (Anthropic provides SDKs for Python and TypeScript); the SDK is the framework layer on top of the protocol. The distinction matters when evaluating adoption cost: you're not adopting a framework with its opinionated structure, you're implementing a protocol that can live inside whatever structure you already have.
An LLM (Large Language Model) is the AI system that reasons and generates text; MCP is the protocol that tells the LLM how to interact with external tools. The relationship is one-directional: LLMs use MCP — MCP does not use or require an LLM. An LLM without MCP can only work with information it was trained on and whatever appears in its context window. An LLM with MCP can call external servers to retrieve current data, execute code, query databases, and take actions in other systems — then incorporate those results into its reasoning. MCP adds the tool-use capability; the LLM supplies the reasoning about when and how to use those tools. The confusion between MCP and LLM typically indicates someone comparing a capability (tool-calling) with the system exercising that capability (the model) — the correct comparison is MCP vs. function calling (another tool-use mechanism built into model APIs), not MCP vs. LLM.
Quick check — what did you just read?
What was broken before MCP existed that MCP is designed to fix?
MCP solves the N×M integration problem — before it existed, connecting M AI models to N tools required M×N custom connectors; MCP standardizes the interface so any compliant model can call any compliant tool without custom work.
Is MCP only for Claude?
MCP is an open protocol. ChatGPT, Microsoft Copilot, and Apple Intelligence have all adopted it, which is part of what gives it durability as a standard beyond Anthropic's own ecosystem.
02
## Is MCP Still Worth Betting On?
The complexity calculus is the wrong frame. The real question in 2026 is whether MCP will still be the dominant protocol by the time your integration ships — and that answer requires reading the ecosystem, not the docs.
Key finding
### Betting on MCP is a protocol survival bet, not a complexity tradeoff.
A2A (Google's Agent-to-Agent protocol), native function calling in closed-ecosystem deployments (ChatGPT, Copilot, Apple Intelligence), and direct HTTP tool APIs are not theoretical alternatives — they are active defection paths already visible in the PAA surface . "Don't use MCP when it's too complex" is technically correct and strategically useless for anyone building with a 12-month horizon.
MCP is relevant in 2026 and its durability signal is stronger than at any prior point — but the relevance is conditional on use case in a way no competitor article acknowledges. The strongest durability signal is cross-vendor adoption: ChatGPT, Microsoft Copilot, and Apple Intelligence have all shipped MCP support, meaning no single company can deprecate or replace the protocol unilaterally without breaking their own integrations. The 2026 MCP roadmap confirms active governance investment — transport scalability, enterprise readiness, and a governance working group are all in-flight. What no competitor article acknowledges is that relevance and fitness-for-your-use-case are orthogonal: MCP can be a durable protocol standard and still be the wrong choice for a specific latency-sensitive or single-tool integration. The practitioner question is not "is MCP relevant" but "is the problem MCP solves the problem I have" — and the ecosystem signal helps answer the first; the architecture of your integration answers the second.
MCP is not deprecated — the current stable specification is 2025-11-25 and a 2026-07-28 release candidate has been published with significant transport and extensibility improvements. A protocol with an active release candidate, multi-vendor adoption across competing platforms, and an official 2026 governance roadmap is the opposite of deprecated. The question surfaces in search because MCP's early adoption phase produced a large number of low-quality MCP servers that have been abandoned — which creates confusion between "MCP servers being deprecated" and "MCP the protocol being deprecated." Individual MCP servers deprecate; the protocol has not. The 2026 roadmap explicitly lists "governance maturation" as a priority, including a contributor ladder and working groups — infrastructure you only invest in for a protocol you intend to be running for years.
The defection signal in the PAA surface is real, but it is use-case-specific rather than a wholesale ecosystem move. Practitioners are moving away from MCP for specific workloads — particularly latency-sensitive single-tool integrations — because the protocol overhead (tens to hundreds of milliseconds per invocation) is architectural and cannot be tuned away, making direct REST calls or native function calling the correct choice for those scenarios. A second, smaller defection is organizational: teams that adopted MCP early for simple automation use cases discovered that a shell script or cron job does the same work with zero protocol overhead. What the PAA questions signal is not that MCP is failing but that a correction is underway — the early hype surface over-applied MCP to integrations that never needed a protocol layer. The result is practitioners who correctly concluded MCP was wrong for their use case, but incorrectly generalized that conclusion into "MCP is wrong."
The industry is not moving away from MCP — the industry is stratifying MCP adoption by use case, which looks like defection from the outside. The stronger indicator of industry trajectory is that Google's A2A protocol, the most credible competitor to MCP's ecosystem coordination role, is positioned as complementary rather than competing: A2A handles agent-to-agent coordination while MCP handles agent-to-tool connections. Apple Intelligence, Microsoft Copilot, and ChatGPT are all shipping MCP support in 2026 — the set of vendors who would benefit most from a competitor to MCP being viable are the vendors most committed to it. The search question "is the industry moving away from MCP" is itself a signal: it reflects practitioners who have seen real-world MCP failures (security incidents, performance overloads) and are trying to determine whether those are early-adoption edge cases or signs of structural protocol weakness. They are edge cases.
Nothing has replaced MCP as the dominant agent-to-tool protocol standard as of 2026 — the closest alternative is native function calling within single-provider ecosystems, but that solves a narrower problem than MCP addresses. Google's A2A (Agent-to-Agent protocol) is the most commonly cited replacement candidate, but it operates at a different layer: A2A coordinates between AI agents, MCP connects agents to tools — a system can and does use both simultaneously. Direct REST API calls are a legitimate alternative when portability and multi-tool orchestration are not requirements — but REST does not replace MCP at the protocol layer, it replaces the use cases where MCP was never the right choice. The practical state in 2026: MCP owns agent-to-tool protocol, A2A owns agent-to-agent coordination, and native function calling owns single-provider single-tool integrations. Three layers, three tools — none replacing the others.
Anthropic has not abandoned MCP — Anthropic transferred MCP governance to an independent multi-vendor body specifically to prevent it from being an Anthropic-controlled protocol that competitors would be reluctant to adopt. The governance transfer is the strongest evidence of long-term commitment: Anthropic gave up unilateral control of the specification precisely to make it a durable industry standard rather than a proprietary Anthropic tool. The 2026 roadmap lists enterprise readiness, transport evolution, and governance maturation as the four active priorities — all of which require continued investment, not abandonment. Claude Desktop remains the reference MCP client implementation and Claude Code ships with built-in MCP client support. The "did Anthropic abandon MCP" question in the PAA surface reflects early-stage ecosystem anxiety, not observable evidence.
MCP is not out of date — the 2025-11-25 stable specification is the current standard, and a 2026-07-28 release candidate introduces stateless protocol core and an official extensions framework that addresses the scalability limitations practitioners have identified as MCP's most significant architectural constraint. The 2026-07-28 release candidate's stateless protocol core — eliminating session headers so any MCP request can land on any server instance — directly resolves the sticky-routing problem that makes MCP difficult to scale horizontally, which is the primary architectural criticism of the protocol in production deployments. A protocol with an active release candidate in flight is current by definition. What is out of date are many of the MCP tutorials and server implementations published in 2024 and early 2025, before the 2025-11-25 stable spec — the protocol has evolved and most existing guides have not.
MCP is not outdated as a protocol, but specific MCP implementations and architectural patterns from 2024 are legitimately obsolete. The stateful session model in the 2025-11-25 spec — which requires sticky routing for horizontal scaling — is being replaced in the 2026-07-28 release candidate by a stateless protocol core that any load balancer can route without coordination. Production teams that built MCP infrastructure against the 2024 draft spec and are running into horizontal scaling constraints are experiencing real architectural debt, not protocol obsolescence. The correct frame: the underlying standard is evolving to fix known weaknesses; the teams whose infrastructure is "outdated" are those who built against pre-stable versions and have not migrated. The release candidate's ten-week Tier 1 SDK window means that SDK-based implementations will be straightforward to update; custom protocol implementations will require more deliberate migration work.
A2A (Google's Agent-to-Agent protocol) is not dead — it is active and positioned as complementary to MCP, not competing with it. A2A handles coordination between AI agents (one agent dispatching tasks to another); MCP handles agent-to-tool connections (an agent calling a file system, database, or web API) — a well-architected multi-agent system uses both protocols simultaneously, with A2A orchestrating at the agent layer and MCP connecting each agent to its tools. The "is A2A dead" question in the PAA surface reflects the same protocol-survival anxiety as the MCP trajectory questions — practitioners are trying to determine which protocol bets are safe. The practical answer is that A2A and MCP are not competing for the same layer, so the question of which one "wins" is a category error. The correct question is whether your system has agent-to-agent coordination needs (A2A) and agent-to-tool needs (MCP) — most agentic systems have both.
Which adoption signals actually matter?
Which of the following signals most strongly indicates a protocol standard is durable — not just hyped?
Cross-vendor adoption from competing platforms is the strongest durability signal — it means no single company can deprecate or replace the protocol unilaterally without breaking their own integrations.
Is A2A (Google's Agent-to-Agent protocol) a replacement for MCP?
A2A and MCP are complementary, not competing — A2A handles agent-to-agent coordination while MCP handles agent-to-tool connections. An agentic system can use both simultaneously.
03
## The Auth and Transport Layer Exposed.
Every article about how MCP works tells you it uses JSON-RPC over HTTP with OAuth. Which parts of that stack are mandatory versus configurable, and where the auth implementation diverges from standard OAuth flows, is information that no competitor article provides.
MCP uses OAuth 2.1, but only for remote server deployments — local stdio transports require no OAuth at all. The critical clarification that no competitor article makes is that MCP mandates Authorization Code flow with PKCE, not the simpler client credentials flow that many backend developers default to when implementing OAuth for service-to-service communication. The distinction matters because client credentials (service account tokens) are easier to implement and widely used for API authentication, but MCP's security model requires the delegated-authorization pattern that Authorization Code + PKCE provides. Teams building MCP servers for the first time who reach for client credentials because they're familiar with it from other service-to-service auth implementations will find their implementation non-compliant. Budget the Authorization Code + PKCE implementation time explicitly — it is not optional for remote deployments.
MCP requires OAuth 2.1 only for remote server deployments — the stdio transport used for local (same-machine) integrations has no OAuth requirement. This transport-conditional auth requirement is the single most important implementation detail for any team evaluating MCP adoption cost: if your use case is a local MCP server running on the same machine as the client, OAuth is not in scope; if your use case is a remote server that any compliant client connects to over the network, OAuth 2.1 with Authorization Code + PKCE is mandatory, not optional. The practical implication: a solo developer building an MCP server for personal use with Claude Desktop faces zero auth overhead. An engineering team building a shared MCP server for multi-user remote access faces a full OAuth 2.1 implementation — dynamic client registration, PKCE, token storage, refresh flows, and the security hardening that the postmark-mcp breach demonstrated is necessary even for internal tools.
MCP's remote transport requires OAuth 2.1 — it does not support API key authentication, JWT bearer tokens issued by internal services, or session cookie authentication at the protocol level. Local stdio transports bypass the auth layer entirely, so "MCP only supports OAuth" is accurate for remote deployments and irrelevant for local ones — but teams who discover this constraint after committing to a remote deployment architecture will find there is no protocol-compliant workaround. Some MCP server implementations add custom API key handling at the application layer on top of the protocol, but this is a non-standard extension, not a supported alternative. The MCP 2026 roadmap identifies SSO integration as an "enterprise readiness" priority that is currently the "least defined" — meaning enterprise-grade auth patterns beyond basic OAuth 2.1 are still unresolved at the specification level. For teams whose auth infrastructure is built around SAML, LDAP, or internal JWT issuers, the current MCP auth model requires a dedicated translation layer.
MCP supports multiple transports — HTTP (with Server-Sent Events for streaming), stdio, and WebSockets — and is not exclusively HTTP-based. The stdio transport runs over standard input/output streams with no network layer, making it suitable for local integrations where HTTP would add unnecessary complexity; the HTTP + SSE transport is the standard for remote deployments. The current stable specification (2025-11-25) defines Streamable HTTP as the remote transport, but the 2026 roadmap identifies "transport evolution and scalability" as a top priority because Streamable HTTP has documented production challenges with horizontal scaling. The 2026-07-28 release candidate addresses this by introducing a stateless protocol core that removes the sticky-routing constraint that makes Streamable HTTP difficult to scale across multiple server instances.
MCP requires HTTPS for all remote server deployments — HTTP is only valid for stdio local transports where no network layer is involved. The requirement is not optional: a remote MCP server operating over plain HTTP exposes all tool descriptions, tool arguments, and tool results in plaintext — and because tool descriptions are processed as instructions by the AI model, plaintext transmission of tool descriptions is a prompt injection surface that attackers can exploit at the network layer. The practical consequence: any MCP remote server that accepts HTTP connections without TLS should be treated as misconfigured by default, not as a valid "internal-only" deployment. Internal networks are not a substitute for transport encryption when the payloads include AI model instructions. HTTPS enforcement is deployment infrastructure, not application code — but it is the first verification any MCP deployment should make before exposing a server to any client other than localhost.
MCP is built on JSON-RPC 2.0 — a protocol for remote procedure calls encoded as JSON messages — but the JSON encoding is a transport detail, not what MCP is. What distinguishes MCP from "just a JSON API" is the stateful session lifecycle and capability negotiation: a JSON API call is stateless (each request is independent); an MCP session is stateful (the server advertises capabilities at connect time, and both parties maintain session state across multiple tool invocations). The confusion is understandable because an MCP message looks like a JSON API payload — it has a method, params, and result field. The difference is in what those fields encode: not CRUD operations on resources, but tool invocations within a capability-negotiated session. Practitioners who have built REST APIs find MCP's JSON encoding familiar; the session model is what requires the conceptual adjustment. If the session model isn't providing value for your use case, you likely don't need MCP.
MCP auth and transport — verify before you deploy
0 / 5 done
- Confirm your deployment transport: stdio (local, no OAuth required) or SSE/HTTP (remote, OAuth 2.1 mandatory)
- Verify your OAuth implementation uses Authorization Code + PKCE — MCP remote servers do not support the client credentials flow
- Confirm HTTPS is enforced end-to-end — HTTP is only valid for stdio local transports, not remote server deployments
- Audit your tool descriptions for untrusted input — tool descriptions are processed as instructions by the model, making them a prompt injection surface
- Measure your transport overhead: stdio vs SSE vs HTTP streaming each carry different per-invocation latency that compounds across a multi-tool session
04
## MCP vs. REST, HTTP, and Everything Else.
MCP does not replace REST. The three architectural scenarios where reaching for MCP creates more complexity than it removes are precisely the ones most articles use as MCP success cases.
Use MCP over a direct API when two conditions are true simultaneously: your agent needs to orchestrate multiple distinct tools within a single session, and portability across AI models matters. The decision flips to direct API the moment either condition drops: a single-tool integration has no session state to manage across calls, so MCP's stateful session is overhead without benefit; a locked single-provider deployment has no portability requirement, so MCP's cross-model compatibility is irrelevant. The latency constraint is the third variable: MCP adds tens to hundreds of milliseconds per invocation at the protocol layer — this overhead is architectural and cannot be mitigated by simplifying the MCP server implementation. If your integration must complete in under 200ms end-to-end, that overhead may consume your entire latency budget before the tool does any work. The correct three-question test: Does the agent need multiple tools in one session? Does the integration need to survive a model change? Can the use case tolerate MCP's protocol overhead? All three "yes" answers justify MCP; any single "no" answer warrants a direct REST call.
Use MCP instead of direct HTTP when your agent needs capability negotiation — discovering at runtime what an external system can do rather than hardcoding the API surface at design time. Dynamic capability discovery is MCP's primary architectural advantage over direct HTTP: an MCP server tells the client what tools it has; a REST API requires the client to know the endpoint structure before the first call. For integrations where the tool set is stable and known at design time, this advantage vanishes — and direct HTTP is simpler to implement, easier to debug, lower latency, and requires no protocol-layer auth overhead. The honest comparison: MCP earns its complexity overhead when you are building a system where the set of available tools may change without redeploying the client, or where the same client code must run against multiple different MCP servers. For everything else, a typed REST client with an OpenAPI spec gets you there faster with fewer moving parts.
MCP cannot replace REST APIs — they solve different problems at different layers of the stack, and the scenarios where MCP is the right choice are a subset of what REST handles, not a superset. REST is a stateless request-response architecture for accessing and manipulating resources; MCP is a stateful session protocol for AI agents to discover and invoke external capabilities — the two solve adjacent, not identical, problems. Most MCP servers are built on top of REST APIs: the MCP server wraps an existing REST endpoint, translates the AI model's structured tool call into an HTTP request, and returns the response. Replacing REST with MCP would be replacing the underlying API with the wrapper — the opposite of the correct architecture. The practical frame: REST is how systems talk to each other; MCP is how AI agents talk to systems. Both layers persist in a well-architected agentic system.
MCP is slower than a direct API call for the same operation — the protocol overhead adds tens to hundreds of milliseconds per invocation, and this is architectural, not a tuning problem. The latency penalty comes from three sources that cannot be optimized away: the capability negotiation handshake at session start, the JSON-RPC message serialization and deserialization on each tool call, and the transport layer overhead of the SSE or HTTP streaming connection. A direct REST API call bypasses all three overhead sources. The correct question is not "is MCP faster" but "does MCP's value — stateful sessions, capability negotiation, cross-model portability — justify the latency overhead for my use case." For batch processing, multi-step orchestration with long-running tools, and integrations where tool results feed into subsequent tool calls, the session value justifies the latency cost. For a single deterministic lookup that must complete in under 150ms, direct REST is the only viable choice.
MCP will not replace APIs — it will add a protocol layer on top of APIs for agentic use cases, in the same way HTTP did not replace TCP but became the dominant application-layer protocol for web traffic. The analogy to HTTP is instructive: HTTP standardized how clients and servers communicate over the web without replacing the underlying TCP infrastructure; MCP standardizes how AI agents communicate with tool servers without replacing the underlying REST APIs those servers expose. The realistic 2026 scenario: most services will continue to expose REST APIs as their primary integration surface; a growing subset will additionally expose MCP servers for agentic clients that need dynamic tool discovery and stateful sessions. Both surfaces coexist in the same infrastructure. The practitioners who will be caught out are those treating "API" and "MCP server" as mutually exclusive choices rather than as different interfaces to the same underlying capabilities.
MCP is not the new HTTP — it is more accurately the new Language Server Protocol: a specialized standard for a specific client-server relationship (AI agent to tool server) that solves the N×M connector problem for one class of software interaction. HTTP is a general-purpose application-layer protocol used by virtually every networked application; MCP is purpose-built for agentic AI tool-calling, a narrower use case that shares HTTP as its transport but is not a replacement for it. The "MCP is the new HTTP" framing (cited by some practitioners) is a claim about trajectory and ubiquity, not architecture. For that claim to be true, MCP would need to become as universal as HTTP — meaning every networked service exposes an MCP interface alongside its HTTP interface. The 2026 roadmap suggests this is aspirational rather than imminent, and it is not a reason to adopt MCP for integrations where the HTTP layer is already sufficient.
MCP and Zapier solve similar problems — connecting applications — but at fundamentally different layers: Zapier connects applications through predefined human-authored automation flows; MCP connects AI agents to tool servers so the agent can decide at runtime what to call and in what sequence. The defining difference is autonomy: a Zapier workflow is static — a human defined "when X happens, do Y"; an MCP integration is dynamic — the AI model reads available tools and decides what to call based on its reasoning about the current task. For teams currently using Zapier for deterministic automations, the decision calculus is straightforward: if the automation logic is well-defined and human-designed, Zapier or a direct API integration is simpler and cheaper to operate. MCP becomes relevant when you need the AI model to be the decision-maker about which tools to invoke — not when you need to connect two services and have already decided what should happen.
MCP is a protocol; Copilot (Microsoft) is an AI assistant product that has adopted MCP as one of its tool-calling mechanisms. The distinction matters because "switching from MCP to Copilot" is a category error — Microsoft Copilot uses MCP to connect to external tools, so Copilot and MCP are complementary, not competing choices. The relevant comparison for practitioners is between MCP (the open protocol) and Copilot's native function calling (Microsoft's proprietary tool-calling mechanism within their AI ecosystem). Native Copilot function calling is simpler to implement for Microsoft 365 integrations and carries no MCP protocol overhead — but it is locked to Copilot and does not port to Claude, ChatGPT, or other AI models. MCP-wrapped tools used by Copilot can also be used by any other MCP-compliant client. For organizations already standardized on Microsoft 365 and committed to Copilot, native function calling is the faster path; for organizations wanting to hedge across AI providers, MCP is the portability layer.
Pick your integration pattern — see when MCP wins and when it doesn't
MCP — Model Context Protocol
- Stateful session with capability negotiation — the server advertises its tools dynamically
- Any compliant AI model can call any compliant MCP server without a custom integration
- Multi-tool orchestration across a single session without re-authentication
- Tens to hundreds of milliseconds overhead per tool invocation — architectural, not tunable
- OAuth 2.1 mandatory for remote deployments — significant implementation overhead for simple use cases
- Overkill when a single deterministic endpoint is all the agent needs
Use MCP when your agent orchestrates multiple tools across a stateful session and portability across AI models matters. Skip it when you need one fast, deterministic call.
REST / HTTP — direct API
- Stateless — no session overhead, predictable latency
- No protocol layer between the agent and the endpoint — simpler debug surface
- Every existing API is already REST — zero migration cost
- Every AI model needs a custom integration — no portability across models
- No dynamic capability negotiation — the model must know the API surface at design time
- N×M custom connectors as you scale models and tools
Use direct REST when your integration is deterministic, latency-sensitive, or involves a single endpoint. REST is not going away — it solves a different layer of the problem.
Native Function Calling (OpenAI / Copilot / Apple)
- Zero protocol overhead — function calling is part of the model API response schema
- Simplest path for single-provider deployments — no MCP server to host or maintain
- Full access to provider-specific features (streaming, parallelism) without a transport layer
- Provider lock-in — function schemas are not portable across OpenAI, Anthropic, and Google APIs
- No cross-model portability — a function defined for GPT-4o does not run on Claude without rewriting
- No multi-server session — each function call is stateless and provider-scoped
Use native function calling when locked to one AI provider and portability is not a current requirement. It is the fastest path and the highest lock-in path simultaneously.
05
## When MCP Becomes the Problem.
The pitfall is not that MCP is complex — it's that the complexity penalty is architectural and shows up after you've shipped. The postmark-mcp breach and SuperAGI's production overload incidents both followed the same pattern: MCP added overhead to a use case that never needed a protocol layer.
Skip MCP when any one of three conditions is true: your agent needs a single deterministic call to one endpoint; your integration is locked to one AI provider with no planned model migration; or your use case cannot tolerate tens to hundreds of milliseconds of added per-invocation latency. The conditions are independent — any single one is sufficient to disqualify MCP, because each one removes the specific value MCP provides: multi-tool session management, cross-model portability, and acceptable latency overhead respectively. The postmark-mcp breach illustrates the fourth disqualifying condition: an MCP integration where tool descriptions are sourced from untrusted external inputs without sanitization. Tool descriptions are processed as instructions by the AI model — an attacker who controls a tool description controls the model's behavior within that session. The correct frame is not "MCP is too complex" but "MCP adds overhead to a problem I don't have" — the complexity is justifiable when the problem is real, unjustifiable when it is not.
The three verified production pitfalls of MCP are latency accumulation, auth under-implementation, and tool description injection — and all three share the same root cause: adopting MCP before understanding which parts of its architecture are the cost you pay and which are the value you receive. Latency accumulation is the most common: MCP's per-invocation overhead compounds across multi-tool sessions — a five-tool session with 100ms overhead per call adds 500ms of protocol latency before any tool does substantive work, which is unacceptable in user-facing interactions. Auth under-implementation is the most dangerous: the postmark-mcp breach demonstrated that an MCP server with incomplete OAuth hardening can be silently hijacked — in that case, malicious BCC instructions were injected via tool descriptions, turning a legitimate email server into an exfiltration channel. Tool description injection is the most architecturally novel: because tool descriptions are processed as model instructions, any untrusted input that reaches a tool description field is a prompt injection vector, not a data sanitization problem.
Use MCP when multi-tool orchestration, cross-model portability, and tolerable latency all align; skip MCP when any one of those conditions is absent. The decision is binary for each condition: MCP's stateful session adds no value without multiple tools; MCP's cross-model portability is irrelevant if you are locked to one provider; and MCP's latency overhead is architecturally non-negotiable — there is no MCP implementation that avoids it for latency-sensitive use cases. The practical test: if your integration can be described as "call this one endpoint with these arguments and return the result," MCP is the wrong choice regardless of how many MCP servers exist in the ecosystem. If your integration requires the AI model to discover what tools are available, call multiple tools in sequence, and adapt its plan based on intermediate results — that is the use case MCP was built for. SuperAGI's production overload incidents confirm that high-frequency MCP orchestration requires deliberate capacity planning; the protocol overhead is not free at scale.
MCP is inefficient for use cases where its architecture provides no benefit — the inefficiency is not a defect in the protocol but a mismatch between the problem MCP solves and the problem being applied to it. The specific source of inefficiency is the stateful session model: establishing a session, negotiating capabilities, maintaining connection state, and handling JSON-RPC message framing all add overhead that a stateless direct REST call does not incur — and that overhead delivers no value when the integration is a single deterministic call that does not need session state or capability negotiation. The 2026-07-28 release candidate's stateless protocol core addresses one dimension of this inefficiency — removing session headers so any server instance can handle any request — but does not eliminate the per-invocation JSON-RPC overhead. The practitioner frame: measure actual per-invocation latency in your environment before standardizing on MCP; the "tens to hundreds of milliseconds" figure is a reported range, and your actual overhead depends on transport, server implementation, and network topology.
The three strongest reasons not to use MCP are: the integration does not require a stateful multi-tool session; the auth implementation complexity is unjustified for the use case; and the team has not audited tool description inputs for injection risk. The auth implementation reason is particularly underweighted in current discourse: implementing OAuth 2.1 with Authorization Code + PKCE correctly — including token storage, refresh flows, and the security hardening that prevents the postmark-mcp breach pattern — requires deliberate engineering investment that is not in scope for a simple tool integration. Teams that underestimate this and ship MCP servers with incomplete auth hardening produce a worse security posture than a well-implemented direct API with a static token, because MCP's tool description attack surface is novel and not covered by standard web application security checklists. The correct question before adopting MCP is not "can we make this work" but "does the value of stateful multi-tool orchestration and cross-model portability justify the implementation overhead of correct OAuth 2.1 and tool description sanitization."
Use MCP when three architectural conditions align: the agent needs to orchestrate multiple distinct tools within a single session, the integration must remain portable across AI models or providers, and per-invocation latency of tens to hundreds of milliseconds is acceptable for the use case. The highest-value MCP use case in 2026 is a multi-model agentic system where different AI models handle different sub-tasks and each needs access to a shared set of tools — MCP's cross-model portability means the tool servers are written once and callable by Claude, ChatGPT, and Copilot without rewriting integration code for each provider. A secondary strong signal is development tooling: AI-assisted coding assistants that need access to file systems, terminals, databases, and documentation simultaneously are the use case that MCP's stateful session and capability negotiation were designed for. Claude Desktop and Cursor's MCP adoption are leading indicators of the use case MCP wins — not generic automation, but agentic development environments where tool orchestration complexity is genuinely high.
The architectural disadvantages of MCP (the Model Context Protocol, not MPC the economic term) are four: latency overhead, auth implementation cost, horizontal scaling constraints, and the tool description injection attack surface. The most practically significant disadvantage for production systems is that MCP's current stable specification requires sticky routing for horizontal scaling — stateful sessions must land on the same server instance, which prevents standard load balancer behavior and requires session-aware routing infrastructure that teams building simple REST services have never needed before. The 2026-07-28 release candidate addresses this with a stateless protocol core, but that spec is a release candidate, not the stable version — teams building production systems on the current stable spec (2025-11-25) must design for sticky routing now and plan for migration when the new spec stabilizes. The tool description injection attack surface is the least-understood disadvantage: because AI models process tool descriptions as instructions, any input path that reaches tool description fields is a security boundary requiring the same sanitization discipline as SQL injection or XSS attack surfaces.
Should you use MCP for this integration?
Does your agent need to call multiple distinct tools — file system, database, web search, email — within a single session?
Yes — multi-tool orchestration across one session
No — one tool, one deterministic call
Does the integration need to work across more than one AI model or provider (e.g. Claude today, GPT-5 next quarter)?
Yes — model portability matters
No — locked to one provider
Can your integration tolerate tens to hundreds of milliseconds of added latency per tool invocation?
Yes — latency is not the primary constraint
No — latency-sensitive, every millisecond counts
## Read the ecosystem with live PAA data.
MCP Scraper harvests People Also Ask questions at scale — so your MCP decision is based on what practitioners are actually searching right now, not what the docs say they should ask.
Start free →
---
## Who Hallucinates More: ChatGPT or Claude?
Canonical URL: https://mcpscraper.dev/blog/who-hallucinates-more-chatgpt-or-claude/
Published: 2026-05-23T00:00:00.000Z
Modified: 2026-05-23T00:00:00.000Z
Five benchmarks, two competing verdicts, and the one variable every comparison article gets wrong. Know which model to trust before the answer matters.
01
## What You're Actually Asking About.
Before comparing rates, you need to know what the word "hallucination" means — and it turns out no benchmark, no article, and no AI company uses the same definition. A 3% rate and a 15% rate can describe the same model on the same day.
Terminology
### Hallucination and confabulation are not the same thing — and the distinction explains why Claude and ChatGPT get different labels.
Confabulation is the specific pattern of plausibly gap-filling missing knowledge with invented detail — the brain (or model) connecting dots that were never there. Hallucination is the broader term covering any confident false output. Claude's uncertainty-admission training was designed to interrupt confabulation specifically. ChatGPT's RLHF was tuned on human preference, which tends to reward confident, complete-sounding answers even when the model is uncertain. The same root behavior gets opposite training signals in each system.
AI hallucination is when a language model produces confident, fluent output that is factually wrong — a citation that doesn't exist, a date that never happened, a quote no one said. The term is borrowed loosely from psychiatry, where hallucination means perceiving something that isn't there. In practice, LLM hallucinations look less like delusions and more like plausible-sounding autocomplete: the model generates the statistically likely continuation of a sentence, not a grounded fact lookup. The critical word is "confident" — hallucinations are dangerous not because models are wrong, but because they are wrong without signaling any uncertainty. A practitioner's real concern is not hallucination frequency but hallucination detectability: a model that hallucinates rarely but never hedges is far more dangerous in production than one that hallucinates often and flags it.
AI chatbots hallucinate because they are trained to predict the most plausible next token, not to retrieve verified facts from a ground-truth database. The architecture is fundamentally generative — the model produces text that fits the statistical patterns in its training corpus, and sometimes those patterns lead it to fill gaps with invented specifics. Three compounding factors make hallucination worse: sparse coverage of a topic in training data (the model extrapolates), conflicting information in the corpus (the model blends), and RLHF reward signals that favor fluent, complete-sounding outputs over hedged ones (the model stops saying "I'm not sure"). The reason ChatGPT and Claude hallucinate at different rates on different tasks is not architecture alone — it is which of these three failure modes each system's training most aggressively corrects for. If your task exposes sparse training coverage (niche domain knowledge, recent events), neither model can save you without grounded retrieval.
Confabulation in AI is the specific pattern where a model fills a knowledge gap with invented-but-plausible detail rather than refusing or hedging — the model "connects the dots" that were never actually there. The clinical term comes from neurology, where patients with certain memory disorders produce false memories that feel entirely real to them. In LLMs, confabulation is the mechanism behind the most dangerous class of hallucinations: not random nonsense but well-constructed fabrications — a fake paper with a real author's name, a plausible-sounding legal citation, a drug dosage derived by averaging nearby real figures. The distinction matters for tooling: hallucination detectors that look for low confidence scores will often miss confabulation, because the model's internal confidence on a confabulated output can be high. Grounding against primary sources — not just asking the model to self-check — is the only reliable counter.
Hallucination is the broad category; confabulation is the specific failure mode where the model invents plausible gap-fills rather than flagging its own uncertainty. All confabulation is hallucination, but not all hallucination is confabulation — a model that confidently states a wrong date is hallucinating, but it isn't necessarily confabulating if the error traces to a corrupted training example rather than a gap-bridging inference. The distinction changes what interventions work: suppressing confabulation requires training models to recognize the edges of their own knowledge and refuse at those boundaries (which is what Constitutional AI's self-critique loop does for Claude). Suppressing hallucination more broadly requires grounding — retrieval-augmented generation, citation enforcement, source verification. Practitioners who use the words interchangeably will apply the wrong fix.
No — hallucination is a failure of knowledge, not a failure of intent, which means the usual remedies for dishonesty (adversarial red-teaming, filtering, policy enforcement) don't reduce it. A lying agent knows the truth and conceals it; a hallucinating model has no ground-truth representation to conceal — it generates the output that fits the learned distribution, whether that output is accurate or not. This distinction is not just philosophical. Treating hallucination as lying leads organizations to apply trust-and-safety interventions (content moderation, output filtering) rather than epistemic interventions (grounding, uncertainty calibration, retrieval). The more practically damaging confusion is the reverse: treating hallucination as a fixable "bad behavior" that fine-tuning will eventually eliminate, rather than as a structural property of generative models that requires architectural solutions.
ChatGPT makes things up because its RLHF training consistently rewarded fluent, complete-sounding answers — and human raters often cannot tell in the moment whether a specific claim is true. When the model encounters a query at the edge of its training knowledge, it faces two options: produce a hedged, incomplete answer (which RLHF raters historically penalized as unhelpful) or produce a fluent, confident-sounding answer that fills the gap (which raters often rewarded as useful). Over millions of training examples, that signal compounds: the model learns that confident gap-filling is the preferred behavior. OpenAI's release notes for GPT-5.5 Instant specifically cite "reduces hallucination in sensitive areas such as law, medicine, and finance" as a named improvement — which is an implicit acknowledgment that prior versions were not calibrated to refuse when uncertain. The fix is not better knowledge; it is better uncertainty signaling.
02
## The Verdict Depends.
One proprietary test shows Claude hallucinating more than ChatGPT (15% vs. 12%). A different benchmark run on the same models the same year shows Claude with the lowest contradiction rate of five providers. Both studies are real. Neither is lying. The winner changes when the measurement changes — and no competitor article tells you which measurement matches your actual task.
Deposition
### Every "Claude wins" verdict was written against a different product than the one you're using today.
GPT-5.5 Instant became the default ChatGPT in May 2026. Claude Opus 4.7 is the current frontier Claude. The top SERP articles comparing hallucination rates were benchmarked primarily on GPT-4 Turbo and Claude 3 variants. The benchmark scores you are reading describe models that are no longer the default. This is not a minor caveat — task-type inversion, refusal-rate confounds, and methodology differences all compound when the model version gap is also wrong. The deposition question is not "which model wins?" It is: "Which benchmark, on which task type, on which model version, measured how?"
Neither model consistently hallucinates more — the winner changes based on the task type, benchmark methodology, and which model version is being measured. On BullshitBench v2, Claude Sonnet 4.6 hits a 3% hallucination rate with a 91% detection rate, while OpenAI GPT models are "stuck in the 55–65% range" for detection. On Vectara's harder enterprise dataset (February 2026), GPT-4.1 scores 5.6% versus Claude Sonnet 4.6 at 10.6% — a reversal. On AA-Omniscience, Claude Opus 4.1 achieves 0% hallucination (via refusal), while GPT-5.5 reaches 86% error on the same benchmark. The honest answer for practitioners: Claude tends to outperform on tasks requiring uncertainty calibration and open-recall; ChatGPT tends to outperform on grounded tasks with source material present. Your use case determines the verdict.
Claude hallucinates less than ChatGPT on open-recall and uncertainty-calibration benchmarks, but GPT models can outperform Claude on grounded generation tasks where source material is provided. On the Vectara HHEM original dataset (April 2025), GPT-5 scores 1.4% versus Claude-3.7-Sonnet at 4.4% — ChatGPT wins. On BullshitBench v2, Claude Sonnet 4.6 scores 3% with a 91% detection rate — Claude wins. On AA-Omniscience, Claude Opus 4.1 achieves 0% hallucination via confident refusal — Claude wins decisively. The most useful reframe: Claude tends to hallucinate less on tasks where "I don't know" is an acceptable output; ChatGPT can score lower on structured summarization tasks where the source material bounds the answer space.
GPT models score higher on grounded factual accuracy when source material is present; Claude scores higher on calibration — knowing when not to answer. On FACTS Overall Scores (grounded generation), GPT-5 scores 61.8 versus Claude Opus 4.5 at 51.3. On AA-Omniscience, Claude Opus 4.1 achieves 0% hallucination while GPT-5.5 reaches 86% error. These are not contradictions — they measure different things. FACTS rewards producing correct answers given a source; AA-Omniscience rewards refusing answers when knowledge is uncertain. Accuracy in a production system means both: getting the answer right when you have the source, and refusing when you don't. No single model currently dominates both dimensions simultaneously.
ChatGPT's hallucination rate in 2026 ranges from 1.4% on Vectara's original RAG benchmark to 86% on AA-Omniscience's domain-knowledge open-recall test — the same model, different methodologies. On BullshitBench v2, OpenAI GPT models are "stuck in the 55–65% range" for hallucination detection. GPT-5 with thinking mode achieves 1.6% on HealthBench (medical domain). O3 hits 51% hallucination on SimpleQA; o4-mini reaches 79% on PersonQA. The number you see in any article reflects the benchmark used, not a universal accuracy property. The most applicable figure depends on your task: if you are doing RAG summarization, Vectara's 1.4% is relevant; if you are asking ChatGPT to recall domain-specific facts without source material, the AA-Omniscience figure is the honest baseline.
Claude's hallucination rate in 2026 spans from 0% (Claude Opus 4.1 on AA-Omniscience, via refusal) to 58% (Claude Opus 4.5 on the same benchmark when not configured to refuse) — a range that makes any single number misleading. On BullshitBench v2, Claude Sonnet 4.6 hits 3% with a 91% detection rate, making it the strongest performer in that benchmark class. On Vectara's enterprise dataset (February 2026), Claude Sonnet 4.6 scores 10.6% and Claude Opus 4.6 scores 12.2%. The spread is explained by task type: Claude's Constitutional AI training produces strong refusal behavior on uncertain factual questions, which collapses the hallucination rate on benchmarks that reward "I don't know" responses and inflates it on benchmarks that penalize non-answers.
Gemini-2.0-Flash-001 holds the lowest published Vectara HHEM score at 0.7% on the original dataset — but that benchmark measures factual consistency in RAG summarization, not open-ended recall. On open-recall benchmarks, Claude Opus 4.1 achieves 0% on AA-Omniscience by refusing uncertain questions, while o3-mini-high scores 0.8% on Vectara. The "lowest hallucination rate" title changes with every benchmark and model release cycle; the more useful question is which model has the lowest hallucination rate on your specific task class. For enterprise RAG pipelines with provided source material, GPT-4.1 at 5.6% on the harder Vectara dataset is currently competitive. For open-domain factual recall with uncertainty, Claude's refusal behavior produces the lowest confirmed error rate.
AI hallucination is measured by comparing model outputs against a verified ground-truth set and scoring the proportion of confident claims that are factually wrong — but the ground-truth set, task type, and scoring rules vary so widely across benchmarks that the resulting numbers are rarely comparable. Three methodology families dominate: RAG consistency tests (Vectara HHEM measures whether a summary stays faithful to the source document), factual recall tests (SimpleQA, PersonQA ask the model open questions with known correct answers), and calibration tests (AA-Omniscience scores how often a model produces wrong answers on questions it should refuse). The same model can score in the top tier on one family and bottom tier on another. Before citing a hallucination rate, the practitioner question is: what task type does this benchmark represent, and does that match what I'm actually asking the model to do?
03
## Why Claude Behaves Differently (And Why That's Complicated.)
Constitutional AI was built to interrupt confabulation at the output layer — not to make Claude more knowledgeable, but to make it refuse when it isn't. That design makes Claude's hallucination rate look better on open-recall benchmarks and worse on grounded tasks where refusing an answer is the wrong move. The "safer model" label hides a trade-off every competitor article misses.
Architecture
### Claude's 0% hallucination score on AA-Omniscience is achieved by refusing to answer — GPT-5.5 attempts the same questions and scores 86% error.
These are not equivalent failure modes. Claude's refusal behavior is a deliberate uncertainty-admission signal trained by Constitutional AI's self-critique loop. GPT-5.5's 86% error rate on that benchmark reflects RLHF training that rewards confident, complete-sounding output even under epistemic uncertainty. A practitioner choosing between them for a task where refusal is unacceptable — a legal brief, a diagnostic intake form, a real-time research summary — needs to know that "lower hallucination rate" may mean "higher refusal rate," not "more accurate answers."
Constitutional AI is Anthropic's training methodology where Claude critiques and revises its own outputs against a set of principles — and yes, it reduces a specific class of hallucination: confabulation driven by overconfidence. The core mechanism is a self-critique loop: at training time, Claude is prompted to evaluate its own responses against a constitution of principles (including honesty norms) and revise outputs that violate them. Over millions of examples, this trains the model to flag uncertainty rather than elaborate plausibly over it. What it does not do is give Claude better knowledge — it makes the model more likely to output "I'm not sure" or refuse at the boundary of its knowledge. The result is measurably lower hallucination rates on open-recall benchmarks and, as a side effect, higher refusal rates on tasks where humans expect confident answers. The "safer model" framing is accurate but incomplete: Constitutional AI reduces dangerous confabulation, not all incorrect outputs.
Claude hallucinates less than ChatGPT on uncertainty-sensitive tasks because Constitutional AI's self-critique training penalized overconfident outputs at the architectural level — not because Claude has better underlying knowledge. ChatGPT's RLHF training was tuned on human preference ratings, and human raters consistently prefer confident, complete-sounding answers to hedged, partial ones — even when the hedged answer is more accurate. That preference signal, applied at scale, teaches the model to fill gaps confidently. Constitutional AI's revision loop applies a different signal: outputs that violate honesty norms (overconfident claims under uncertainty) are scored negatively by the model itself and revised. On benchmarks like AA-Omniscience, this difference is dramatic: Claude Opus 4.1 achieves 0% hallucination by refusing uncertain questions; GPT-5.5 attempts the same questions and produces 86% error. The practical implication is that Claude's advantage narrows or reverses when the task context provides source material that bounds the answer — because grounding reduces the need for uncertainty calibration.
Claude says "I don't know" more than ChatGPT because uncertainty admission was a first-class design goal in Constitutional AI, not an afterthought in RLHF fine-tuning. Anthropic explicitly trained Claude to identify the edges of its own knowledge and signal them rather than bridge them. The constitutional principle "prefer accurate uncertainty estimates over confident wrong answers" was applied via the self-critique loop — meaning at training time, Claude learned to score its own overconfident outputs negatively. ChatGPT's training did the opposite: human raters penalized partial or hedged answers as unhelpful, pushing the model toward confident completeness. For practitioners, the implication is that Claude's "I don't know" is a calibration signal worth respecting — it correlates with genuine knowledge boundaries. ChatGPT's confident answers do not carry the same calibration signal and require independent verification more often.
Claude admits uncertainty more than ChatGPT because its training reward function directly penalized overconfidence, while ChatGPT's reward function indirectly penalized uncertainty by preferring fluent, complete-sounding outputs. These are mirror-image training problems with mirror-image results. At the architectural level, both models have the same epistemic limitation: they cannot know what they do not know. What differs is how each handles that edge. Claude's Constitutional AI self-critique loop was designed to surface that edge and output it. ChatGPT's RLHF fine-tuning learned to smooth over it. The consequence for production use is that when Claude expresses uncertainty, it is more likely to be a genuine signal. When ChatGPT expresses certainty, it is less likely to be a reliable signal than the confident phrasing suggests. This asymmetry is the single most important behavioral difference between the two systems for high-stakes use cases.
Yes — Claude is trained to refuse or heavily hedge questions at the boundary of its knowledge, and this behavior is measurable: on AA-Omniscience, Claude Opus 4.1 achieves 0% hallucination by refusing uncertain domain-knowledge questions rather than attempting them. This refusal behavior is not a safety filter applied after generation — it is a trained output preference baked into the model via Constitutional AI's self-critique loop. The practical consequence is two-sided: Claude produces fewer confident wrong answers than ChatGPT, but it also produces more non-answers on questions where an attempt — even an imperfect one — would be useful. For tasks where a partial answer is better than no answer (brainstorming, hypothesis generation, exploratory research), ChatGPT's higher attempt rate is a feature. For tasks where a wrong answer causes real harm (legal, medical, compliance), Claude's refusal behavior is the more defensible default.
04
## When Getting It Wrong Has Consequences.
ChatGPT has already fabricated legal citations in federal court, hallucinated drug dosages, and invented academic papers that passed first-pass review. The more unsettling risk is newer: when ChatGPT, Claude, and Gemini all hallucinate the same false claim, cross-checking them doesn't give you three independent sources. It gives you the same error three times.
False Consensus Risk
### If three major LLMs hallucinate the same lie about your business, it can become the new truth — and no benchmark measures this.
The correlated hallucination problem emerges from shared training data, overlapping RLHF pipelines, and convergent fine-tuning on the same web corpus. When Claude, ChatGPT, and Gemini all reproduce the same unsupported claim, a practitioner who cross-checks across models gets false triangulation rather than independent verification. This risk is entirely absent from every current competitor article on hallucination rates — and it is most acute for entities (companies, people, products) that appear in training data in ways the entity cannot audit or correct.
The most documented ChatGPT hallucinations include fabricated legal case citations presented to federal courts, invented academic papers with real author names, and confident wrong drug dosages in medical queries. The legal citation failures are the best-documented: in the Mata v. Avianca case, a New York attorney submitted a brief citing multiple cases that ChatGPT invented wholesale — cases that did not exist anywhere in the legal record. Academic hallucinations are structurally similar: ChatGPT generates plausible-sounding paper titles, journal names, and DOIs that pass casual verification because all the component elements (author names, journal names, topic keywords) are real — only the assembled paper is fabricated. The pattern in all major cases is the same: ChatGPT produces hallucinations that are specifically designed, by the training distribution, to pass the first verification step a non-expert would apply.
Yes — the most consequential documented case is Mata v. Avianca, where an attorney used ChatGPT to research case law and submitted a brief citing multiple cases that did not exist, resulting in federal court sanctions. The cases ChatGPT generated were plausible: they had realistic docket numbers, party names consistent with real aviation litigation, and summaries that read as coherent legal precedent. None of them could be located by opposing counsel or the court because they were entirely fabricated. The attorney was sanctioned for failing to verify the citations. What makes this case significant beyond its notoriety is the mechanism: ChatGPT did not produce random nonsense — it confabulated, generating outputs that fit the expected form of real legal citations so closely that a trained attorney did not catch them on first read. This is the confabulation failure mode operating at the level of maximum real-world cost.
Yes — in the Mata v. Avianca case, ChatGPT generated at least six fake legal cases that were submitted to a federal court as real precedent, making this the first major documented instance of LLM hallucination causing legal sanctions against a practicing attorney. The fabricated cases had realistic-looking citations: Varghese v. China Southern Airlines, Shaboon v. Egyptair, Zicherman v. Korean Air Lines, and others — all plausible-sounding aviation negligence precedents. When the court asked for copies of the actual decisions, the attorney could not produce them because they did not exist. The episode became a landmark not just for AI liability but for the broader question of what "verification" means when a model's hallucinations are structurally indistinguishable from real citations to a non-expert reader. Neither Claude nor any other model has a documented comparable case — but the mechanism exists in all models that generate legal text without grounding.
In Mata v. Avianca, a personal injury lawsuit filed in the Southern District of New York, attorney Steven Schwartz used ChatGPT to research aviation negligence precedents and submitted a court brief citing six cases that ChatGPT had fabricated. When opposing counsel could not locate the cited cases, the court ordered Schwartz to produce the actual decisions. He could not — the cases existed only in ChatGPT's output. The court sanctioned Schwartz and his firm. Schwartz's defense was that he was unfamiliar with ChatGPT's tendency to generate false information; the court found that reliance on an AI tool without verification constituted professional negligence. The case is now the canonical example cited in AI liability discussions because it makes concrete the abstract warning that LLM hallucinations have real-world costs — and because the mechanism was confabulation, not noise: the fake cases were structurally indistinguishable from real ones.
Yes — ChatGPT can hallucinate medical information, and the risk is highest in exactly the scenarios where clinicians are most likely to use it: rare conditions, drug-drug interactions, and off-label dosages that are underrepresented in training data. GPT-4o scores 15.8% hallucination on HealthBench, a medical domain benchmark; GPT-5 with thinking mode reduces this to 1.6%, but the improvement is conditional on the thinking mode being enabled and the query being within the benchmark's scope. The practical risk for medical use is not just the headline hallucination rate — it is the confabulation pattern: ChatGPT generating specific-sounding dosages or protocol details that are plausible but wrong, in the confident register that clinical notes require. The consensus across medical AI research is that no current LLM should be used as a primary information source for treatment decisions without RAG grounding against validated clinical databases.
ChatGPT hallucinates on academic citations at a notably higher rate than on general-text tasks because academic citations combine several conditions that maximize confabulation risk: sparse training coverage of specific papers, high structural regularity (author, title, journal, year, DOI), and user verification behavior that rarely extends beyond checking the format. The model has learned that citations follow predictable patterns. When asked for a citation it does not have in training, it generates a citation that fits those patterns — assembling a plausible author name, a realistic journal, and a plausible year around a fabricated paper. Dedicated academic search integrations (like ChatGPT's search tool when enabled) significantly reduce citation hallucination by grounding against live databases. Without grounding, treating any LLM-generated academic citation as provisional and verifying it against Google Scholar, CrossRef, or a DOI resolver is not optional — it is the baseline standard of care.
05
## Choose a Model. Verify the Answer.
The right model for your task depends on whether wrong answers or missing answers cost you more. The right verification method depends on whether you need real-time source grounding, prompt-level controls, or live SERP intelligence to know whether the benchmark you're relying on has already been superseded. Static articles can't give you that. Here's what can.
MCP Scraper
### Every hallucination benchmark is already measuring a different model than the one you're running today.
GPT-5.5 Instant and Claude Opus 4.7 are the current defaults as of May 2026. The top SERP articles were benchmarked on GPT-4 Turbo and Claude 3 variants. Live PAA intelligence from MCP Scraper shows which benchmark claims are currently circulating in the SERP, which task-specific questions are going unanswered (legal, medical, enterprise, scientific writing), and whether the competitive landscape shifted while the static comparison articles were being written. A practitioner who needs the current answer — not a cached verdict — needs a live source, not another article that will be wrong in six months.
You cannot stop ChatGPT from hallucinating entirely, but the four techniques that reliably reduce it are: retrieval-augmented generation with verified sources, chain-of-thought prompting with explicit uncertainty flagging, citation enforcement in the system prompt, and output verification against primary sources before use. RAG is the highest-leverage intervention: grounding responses against a controlled, verified document set eliminates the knowledge-gap confabulation that produces most dangerous hallucinations. Chain-of-thought prompting ("explain your reasoning step by step, and flag any step where you are less than certain") forces the model to surface uncertainty it would otherwise paper over. Adding "if you are unsure, say so explicitly rather than guessing" to system prompts has measurable effect on calibration. None of these eliminate the problem — they reduce it. For high-stakes outputs (legal, medical, financial), human verification against primary sources remains the standard. The tools help; they do not replace verification.
The prompt engineering techniques with the strongest documented effect on hallucination reduction are: explicit uncertainty instructions, step-by-step reasoning requirements, role-scoping, and source-citation enforcement — applied together, not independently. Explicit uncertainty instructions ("say 'I don't know' rather than guessing") improve calibration on both Claude and ChatGPT because both models are capable of signaling uncertainty; they need permission to do it. Step-by-step reasoning forces the model to commit to intermediate claims that can be checked, catching confabulation earlier in the chain. Role-scoping ("you are a fact-checker; do not include any claim you cannot source") narrows the output distribution toward the verified. Source citation enforcement ("provide a source URL for every factual claim") creates a verification trail. The compounding insight most engineers miss: these techniques are not additive linearly — models trained with uncertainty signals (like Claude) show larger improvements from uncertainty prompts than models trained against them (like older ChatGPT versions).
Asking ChatGPT to cite sources reduces the frequency of unverifiable claims in the output, but it does not eliminate fabricated citations — and a fabricated citation with a plausible URL is harder to catch than a claim with no citation at all. The mechanism is real: source-citation prompting shifts the model toward outputs where citation is possible, which correlates with better-grounded claims. But ChatGPT can and does generate plausible-looking DOIs, arXiv IDs, and URLs that resolve to nothing. The citation requirement creates a false confidence layer — the output looks verified when it isn't. The correct workflow is source-citation prompting plus independent verification of every cited source before use. For enterprise pipelines, automated link-checking (do all cited URLs actually resolve?) is the minimum; content verification (does the cited source actually say what the LLM claims it says?) is the standard that eliminates the fabricated-citation failure mode.
Retrieval-augmented generation (RAG) is an architecture that grounds LLM outputs by retrieving relevant documents from a verified source set and providing them as context — and it is currently the most effective single intervention for reducing hallucination in production systems. Instead of asking a model to recall facts from training, a RAG system retrieves the relevant passage from a controlled document store and asks the model to summarize or synthesize it. On Vectara's HHEM benchmark, which specifically tests this summarization-from-source behavior, even older model versions achieve hallucination rates below 5% — because the knowledge gap confabulation mechanism is eliminated when the answer exists in the provided context. What RAG does not stop: hallucinations that occur when the retrieved document does not contain the answer and the model interpolates anyway, and hallucinations in the retrieval step itself (if a semantic search retrieves the wrong document). RAG reduces hallucination dramatically in bounded domains; it is not a universal cure for open-domain queries.
Claude is more trustworthy for tasks where calibrated uncertainty is the primary requirement; ChatGPT is more trustworthy for tasks where producing an answer — even an imperfect one — is the primary requirement. Trust is not a single dimension. On calibration trust (does the model's expressed confidence correlate with its actual accuracy?), Claude leads: Constitutional AI's uncertainty training produces hedges that track genuine knowledge gaps. On coverage trust (will the model attempt the question rather than refuse?), ChatGPT leads: RLHF training produces higher attempt rates on hard questions. The user perception data reflects calibration trust: 62% of verified ChatGPT (GPT-4/4o) users report "occasional confident inaccuracies" versus 24% of Claude 3.5 users. For practitioners, the framework is: trust Claude more when a wrong answer is worse than no answer; trust ChatGPT more when a partial answer is better than a refusal.
For high-stakes tasks where a wrong answer has irreversible consequences, Claude's refusal-calibrated behavior makes it the safer default — but safe use of either model requires human verification against primary sources, not model selection alone. Claude's design advantage in high-stakes contexts is the refusal signal: when Claude says it is uncertain, that signal has been trained to track real knowledge boundaries. ChatGPT's confident outputs in the same situations are less reliably calibrated. However, "safer model" does not mean "reliable without verification" — Claude Opus 4.5 scores 58% hallucination on AA-Omniscience when not configured to refuse, and Claude Opus 4.7 scores 36%. The practical standard for high-stakes work is: use Claude for the calibration signal, ground with RAG against verified sources, and treat any AI-generated factual claim in a legal, medical, or financial context as provisional until independently confirmed.
For enterprise RAG pipelines where source documents are provided, GPT-4.1 currently outperforms Claude on Vectara's harder enterprise dataset (5.6% vs. Claude Sonnet 4.6's 10.6%) — but for enterprise use cases requiring open-domain knowledge retrieval or strict uncertainty signaling, Claude's refusal calibration produces fewer dangerous confident errors. The enterprise use case is split along the same task-type boundary that governs all hallucination comparisons: grounded generation with provided source material favors GPT models; open-domain recall with uncertainty requirements favors Claude. For enterprise deployments at the highest risk level (legal, medical, compliance), the architecture recommendation from available benchmark data is: pair Claude with a RAG pipeline, use Claude's uncertainty signal as a flag for human review, and verify any output where the model expresses high confidence without a cited source. The combination outperforms either model used alone.
No — neither ChatGPT nor any current LLM should be trusted as a primary source for medical or legal advice without independent verification against authoritative primary sources, and the documented failure cases make the risk concrete. In the Mata v. Avianca case, ChatGPT fabricated legal citations that passed initial attorney review, resulting in federal court sanctions — the most expensive hallucination failure mode documented in legal practice. On HealthBench, GPT-4o hallucinates medical information at a 15.8% rate; GPT-5 with thinking mode reduces this to 1.6%, but that reduction depends on task-specific configurations unavailable in standard ChatGPT use. For legal research, both ChatGPT and Claude should be used as research accelerators — identifying potentially relevant cases and concepts — with every specific citation independently verified against Westlaw, LexisNexis, or primary court documents before any professional use. The standard of care is not "use the safer model"; it is "verify every claim."
## Verify before you ship with live data.
MCP Scraper gives you real-time SERP intelligence, PAA harvests, and page extraction so your AI workflows are grounded in current sources — not cached claims from articles written about models that no longer exist.
Start free →
---
## Data Deletion Instructions
Canonical URL: https://mcpscraper.dev/data-deletion
How to request deletion of your MCP Scraper account data or any connected-provider data, including Meta/Facebook data-deletion requests.
Data deletion instructions · Effective July 15, 2026
# Request deletion of your data.
This page explains how to delete your MCP Scraper account, disconnect a provider connection such as Meta/Facebook, Google, LinkedIn, or X, and have us delete the data tied to it. It applies whether or not you are an active subscriber.
Two ways to delete. Use the in-app account deletion, or email us a deletion request — no login required for the email path.
We confirm completion. We verify the request and reply once deletion is done.
Full policy. See the Privacy Policy for retention timelines and legal rights.
## 1. Delete your MCP Scraper account
Sign in and go to Account → Delete account . This cancels active subscriptions, deactivates access, and starts the account-deletion workflow, which removes your account record, stored connections, and stored provider data subject to the retention rules below.
If you cannot sign in, email support@mcpscraper.dev from the address on the account and we will verify and process the deletion manually.
## 2. Delete a single connection
You do not need to delete your whole account to remove one provider connection. Revoke MCP Scraper directly in the provider's connected-app settings so the provider stops issuing new authorized calls:
- Google and YouTube myaccount.google.com/connections
- Meta / Facebook facebook.com/settings?tab=applications
- LinkedIn linkedin.com/mypreferences/d/permitted-services
- X x.com/settings/connected_apps
Then open Dashboard → Integrations , choose the connected account, and select Disconnect . MCP Scraper deletes the stored Nango connection, tokens, bindings, and local connection record, then synchronizes the recurring connected-account quantity in Stripe. Cancel or remove any schedule that used the connection. If the dashboard disconnect fails, email support@mcpscraper.dev with your MCP Scraper account email and provider name. Never send us your password or token.
## 3. Meta / Facebook data-deletion requests
If you arrived here from a Meta data-deletion request, or from a "Remove app" confirmation on Facebook: first revoke MCP Scraper in Facebook's Apps and Websites settings (link above), then email support@mcpscraper.dev from your MCP Scraper account address. Include "Meta data deletion" in the subject and, if known, the connected Page or ad-account name. Do not include Meta credentials.
We verify the request, delete the connection and any stored Meta-derived data (Page, post, comment, ad-account, campaign, or insights data obtained through that connection), and reply to confirm completion.
## 4. Provider-specific retention
- YouTube Authorized data is deleted as soon as possible and no later than 30 calendar days after revocation, unless YouTube permits or law requires retention.
- LinkedIn API content and tokens are deleted promptly upon your deletion request or account closure, subject only to a legal preservation duty.
- Meta, X, Google Analytics, and other providers Connection credentials and provider data are deleted when the connection is deleted, subject to provider rules, legal duties, and short-lived backups.
## 5. What gets deleted
A verified deletion request removes the Nango connection record, OAuth access and refresh tokens, and provider data stored against that connection (or, for a full account deletion, everything tied to your account). We may retain non-identifying aggregate statistics and the minimum record needed to document that a deletion occurred or to meet a legal obligation.
Deleting a connection or account does not undo actions already completed through that connection before revocation. Full details on scope, retention, and your broader privacy rights are in the Privacy Policy .
---
## API & SDK Reference
Canonical URL: https://mcpscraper.dev/docs
Use all 378 MCP Scraper tools from Node.js, Python, the CLI, cURL, or the REST API — including scheduled Search Console tables and filtered private downloads, connected-service exports, web intelligence, browser automation, and durable memory.
API & SDK reference
# Build with every MCP Scraper tool.
One generated contract exposes all 339 MCP tools through four SDK packages, the CLI, direct cURL, and the hosted REST API.
View the SDK on GitHub ↗ Browse the tool surface Connection quickstart Quick start npm install mcpscraper-sdk 339 tools 4 SDK packages 30 typed namespaces Before the first connection
## Know the monthly fee and the usage meter.
A paid plan supplies the shared Credit balance. Each active Nango-backed provider account is a separate 15,000-credit/month add-on drawn from that same balance, and connected work draws from it too as it runs.
- 1 ### Choose a paid plan Starter, Growth, and Scale include Credits, but no active provider connections.
- 2 ### Approve the connection fee Each active Nango connection charges 15,000 Credits from your balance per month. If you later disconnect it, a same-integration replacement inherits that paid period through the end of the billing month.
- 3 ### Use the shared Credits Connected work costs 2 Credits per function run, 2 per proxy request, and 5 per compute-second measured from milliseconds.
- 4 ### Review and remove Use the dashboard Credits tab for current rates, History for settled usage, and Integrations to disconnect an account. The completion message confirms its replacement billing rule.
For a scheduled connection job, add the 75-Credit base for each started run. Agent mode also adds 1.5× the model provider's reported cost. See the billing example and full rate card.
## Authentication
Pass your key in the x-api-key header. Query-string API keys are rejected so keys do not end up in URLs, browser history, or logs.
x-api-key: sk_live_•••• Connected account → RAG
## Store one exact approved read as a searchable snapshot
import_service_connection_to_memory composes a tenant-owned connection read with a Memory write. The server rechecks the exact live readTools grant, redacts the result, marks it as untrusted provider data, writes it at a stable server-generated path, and indexes it in the same request.
### Import one Google Drive read
mcpscraper tools call import_service_connection_to_memory \
--args '{"connectionId":"conn_…","providerConfigKey":"google-drive","tool":"","args":{},"vault":"Library","title":"Drive snapshot"}' \
--json
### Discover before calling
mcpscraper tools call list_service_connections --args '{}' --json
mcpscraper tools call describe_service_connection_tool \
--args '{"connectionId":"conn_…","tool":""}' \
--json
### Required authority
Supply the exact connectionId , matching providerConfigKey , one current read tool, and an existing ordinary notes-vault handle. args and title are optional.
### Stable and inspectable
The caller cannot choose the path. The same connection, tool, and canonical arguments upsert the same Markdown snapshot. The receipt includes path, hash, source bytes, indexed chunks, and search status.
### Bounded by design
Arguments are capped at 64 KiB and the serialized result at 1 MB. Binary, base64, oversized, inactive, unapproved, action, admin, channel-vault, and secure-vault requests fail closed.
This is one snapshot from one approved read. It does not paginate, hydrate a corpus, import an entire account, run continuously, propagate deletions, or build normalized tables. A successful response reports search_ready ; if storage succeeds without indexed chunks, it explicitly reports stored_not_indexed . Use export_connected_service_data only for its supported Gmail, Google Calendar, Google Search Console, Zoom, Resend, and Meta datasets.
Connected accounts
## Export a supported time range in one call
Use export_connected_service_data for its dedicated Gmail, Google Calendar, Google Search Console, Zoom, Resend, or Meta adapters. It is separate from the one-read Memory snapshot tool. For these supported datasets, the server owns pagination and delivery; large results become private JSONL instead of overflowing the agent context.
### Last seven days of email
mcpscraper tools call export_connected_service_data \
--args '{"connectionId":"conn_…","dataset":"emails","lastDays":7}' \
--json
### Renew an expired download link
mcpscraper tools call renew_connected_data_download \
--args '{"artifactId":"artifact_…"}' \
--json
### Resend operating history
mcpscraper tools call export_connected_service_data \
--args '{"connectionId":"conn_…","dataset":"resend_data","lastDays":7,"maxItems":2000}' \
--json
### Search Console performance
mcpscraper tools call export_connected_service_data \
--args '{"connectionId":"conn_…","dataset":"search_console_performance","lastDays":28,"maxItems":5000}' \
--json
### Inspect multiple Search Console URLs
mcpscraper tools call read_service_connection \
--args '{"connectionId":"conn_…","tool":"inspect-urls","args":{"siteUrl":"sc-domain:example.com","urls":["https://example.com/","https://example.com/pricing"]}}' \
--json
### Filtered scheduled Search Console data
mcpscraper tools call export_search_console_table_data \
--args '{"tableName":"gsc_performance_…","filters":[{"column":"date","op":"gte","value":"2026-07-01"},{"column":"query","op":"like","value":"roof repair"}],"sort":[{"column":"clicks","direction":"desc"}],"maxRows":10000}' \
--json
Small live exports return inline. Large exports are private, retained for seven days, and use 15-minute signed URLs. Each live invocation returns at most 5,000 records. Search Console's search_console_performance dataset walks every accessible property for a fresh requested range. For recurring history, create a scheduled action in connection_sync mode; after its first successful run, read the connection's tableName , use table-describe and table-query for exact filtering, then use export_search_console_table_data to download up to 50,000 matching stored rows. Search Console returns provider-selected top rows and is not guaranteed exhaustive. Resend's aggregate resend_data mode walks 12 collections; six core resources can also be selected individually, and each provider page hydrates at most 25 records. A partial live export returns a continuation object that preserves the original range.
Search Console also exposes API-only batches without creating a table: inspect-urls and query-search-analytics-batch are reads; add-sites-batch , submit-sitemaps-batch , delete-sites-batch , and delete-sitemaps-batch are gated actions. They return per-item receipts and can be granted to scheduled agent runs. Delete batches plan by default and require the exact confirmation token from describe_service_connection_tool before execution.
Official remote MCP · OAuth
## Connect Resend without adding 85 global tools
The dashboard opens Resend's hosted OAuth flow at mcp.resend.com/mcp . After consent, MCP Scraper discovers the official account-scoped tools and exposes only the reviewed intersection through its generic connection bridge and each schedule's exact grant.
85 official tools discovered 33 approved reads 45 gated actions 7 admin tools blocked
### Available to reads
Sent and received email, attachments, logs, contacts, broadcasts, templates, automations, domains, segments, topics, webhooks, and other account metadata.
### Available only behind action gates
Drafting, sending, scheduling, updating, verification, removal, event triggers, and audience changes require both the account action switch and the exact tool grant.
### Never delegated
API-key and OAuth-grant administration, the raw editor connector, and raw webhook creation remain outside MCP and Mastra execution. Credential-bearing fields are redacted from approved outputs.
Resend tools are connection-scoped capabilities, not 85 new globally callable names in the base MCP catalog. Inspect the current connection first, then grant an exact read or action. Policy source: official Resend MCP repository ↗ . OAuth and API-key fallback behavior: official MCP documentation ↗ .
Unified tool contract
## All 339 tools, on every supported surface
The catalog contains 238 scraper, connection, and automation tools plus 101 memory tools. Every surface is generated from the same checked-in manifest, so a missing or renamed tool fails the SDK parity check before release.
275 MCP tools 4 SDK packages 30 typed namespaces Surface Install 339 -tool access Reference Node.js — scraper npm install mcpscraper-sdk ScraperClient.tools npm package ↗ Node.js — memory npm install mcpscraper-memory-sdk McpToolsClient npm package ↗ Python — scraper pip install "mcpscraper-sdk @ git+https://github.com/VilovietaSEO/mcpscraper-sdk.git#subdirectory=packages/scraper-python" ScraperClient.tools source package ↗ Python — memory pip install "mcpscraper-memory-sdk @ git+https://github.com/VilovietaSEO/mcpscraper-sdk.git#subdirectory=packages/memory-python" McpToolsClient source package ↗ CLI npm install -g mcpscraper-cli tools list · describe · call npm package ↗ cURL curl + jq JSON-RPC tools/list + tools/call 339-tool catalog ↗
### CLI discovery and invocation
export MCPSCRAPER_API_KEY=sk_live_your_key
mcpscraper tools list
mcpscraper tools describe import_service_connection_to_memory
mcpscraper tools call credits_info --args '{}' --json
### Direct JSON-RPC with cURL
curl --retry 3 --retry-all-errors --retry-delay 1 \
-X POST https://mcpscraper.dev/mcp \
-H "x-api-key: $MCPSCRAPER_API_KEY" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
Canonical source: mcp.tools.json ↗ . The SDK repository also contains generated types, package-specific examples, parity validators, and the complete cURL catalog.
## Endpoint map
Use the smallest surface that matches the job. SERP harvest is for Google results; website endpoints fetch public URLs; YouTube endpoints go directly to YouTube search, channels, and transcripts.
Method Path Use Limit POST /mcp Unified MCP JSON-RPC transport for all 339 scraper, browser, workflow, connection, billing, and memory tools x-api-key; tools/list + tools/call POST /harvest/sync Google SERP harvest: PAA, AI Overview, local pack, forums, videos, perspectives, entity IDs 110–285s by maxQuestions, max 200 POST /harvest Async SERP harvest with job polling and optional webhook callback Callback must be HTTPS public URL GET /jobs, /jobs/:id List or fetch saved SERP harvest jobs for the authenticated user User-scoped POST /extract-url Single public URL extraction: title, meta, headings, markdown body, and JSON-LD schema Public http/https hosts only POST /map-urls BFS internal URL discovery for a public website maxUrls up to 10,000 POST /extract-site Start a durable crawl that retains complete per-page JSON, acquired HTML, and Markdown maxPages up to 10,000; retry with the same idempotency key only for the same intended crawl GET /extract-site/status/:id Poll discovered, attempted, successful, failed, and remaining counts plus artifacts or a stable public error envelope User-scoped POST /extract-site/read Read a site-export manifest or bounded byte windows of one page's JSON, acquired HTML, or Markdown User-scoped; max 1 MB per call; continue from nextOffset POST /extract-site/image Read one preserved image by the imageId returned in the site-export manifest User-scoped; images up to 10 MB POST /screenshot Full-page screenshot of a public URL (desktop or mobile viewport) Public http/https hosts only POST /serp-intelligence/capture Structured SERP Intelligence snapshot for a query (product capture path) 4 Credits headless or 14 headful; optional snapshots add 1 per attempted URL POST /serp-intelligence/page-snapshots Capture optional public ranking-page evidence for one or more URLs/targets 1 Credit per attempted URL; requested capacity held, unused capacity refunded; no private/localhost/internal URLs POST /youtube/harvest YouTube search or channel harvest with video metadata and thumbnails maxVideos 1-500 API, dashboard slider 10-200 POST /youtube/transcribe Transcript by video ID with text, timestamp chunks, Markdown, and HTML Depends on caption/Whisper availability POST /facebook/search Discover advertisers by name or keyword in the Facebook Ad Library maxResults 1-20 POST /facebook/page-intel Scan all ads for an advertiser — copy, headline, CTA, status, creative type Accepts libraryId, pageId, or query POST /facebook/ad Extract full metadata for a single ad by library ID Returns video, image, and text fields POST /facebook/video-transcribe Transcribe an organic Facebook reel, video, watch, or share URL quality best, hd, or sd; renders page first POST /facebook/transcribe Transcribe audio from a direct Facebook ad video CDN URL returned by /facebook/page-intel Use the videoUrl from page-intel, not a public post URL POST /facebook/media Download video or image from fbcdn.net CDN URLs fbcdn.net and cdninstagram.com only POST /maps/search Google Maps business search — up to 50 profile candidates for a category + location maxResults 1-50 POST /maps/place One Google Maps business profile with optional reviews includeReviews + maxReviews; reviews billed per card POST /directory/run Build a directory dataset: select US city markets by population, run Maps search per city in parallel, return CSV minPopulation, maxCities, concurrency POST /instagram/profile-content Discover public Instagram post, reel, and tv links from a profile maxItems + maxScrolls; public content only POST /instagram/media-download Download text, images, reel audio/video, and optional transcript for one post public / login-gated limits apply POST /reddit/thread Capture a Reddit post and its full comment tree (author, score, depth, body) from any reddit.com thread URL maxComments optional; handles Reddit bot wall via residential proxy POST /video/analyze Start an async frame-by-frame + transcript video breakdown; $1 per 120 frames requested (max 480), videos up to 30 minutes Direct .mp4/.webm/.mov URLs; returns runId POST /video/status Poll a video breakdown run; returns progress, then the full report; reconciles billing down if fewer frames were usable Free to call GET /workflows/definitions List runnable workflows for agent packets, market audits, Maps/SERP comparison, PAA briefs, and AI Overview language guidance User-scoped POST /workflows/run Run a hosted workflow and return summary plus artifacts workflowId + input; respects concurrency limit GET /workflows/runs/:id Fetch workflow status and artifact list User-scoped GET /workflows/runs/:id/artifacts/:artifactId Download workflow artifacts such as evidence JSON, CSVs, Markdown briefs, and reports Artifact must belong to caller POST /agent/sessions Open an interactive browser session (stealth + CAPTCHA solving). Returns a session id and watch link Needs ≥1 credit balance POST /agent/sessions/:id/screenshot See the page: screenshot image plus DOM elements with click coordinates and text Billed per minute of use POST /agent/sessions/:id/{goto,click,type,scroll,press,read} Drive the browser — navigate, click, type, scroll, press keys, read the page 120 credits / minute of use POST /agent/sessions/:id/replay/{start,stop} Record an MP4 replay of the session for later review Multiple per session DELETE /agent/sessions/:id Close the browser session and stop the meter Session-scoped GET /me Account info: plan, credit balance, concurrency limit API key auth GET /billing/balance Current credit balance in millicredits API key auth GET /billing/credits Full per-tool cost catalog (live credit prices for every tool) API key auth GET /rates Public pricing contract, including the 15,000-credit/month active-connection add-on and connected function, proxy, and compute rates 2 Credits per function run, 2 per provider proxy request, and 5 per compute-second, prorated from milliseconds GET /ledger Recent credit ledger entries (debits, refunds, top-ups) User-scoped POST /api-key/rotate Rotate your API key Invalidates the previous key POST /memory/mcp-call Generic compatibility gateway to all 87 memory tools — persistent per-user notes, facts, vaults, scheduled actions, tables, and channels {toolName, args}; 10 MB free / 5 GB Pro storage GET /memory/connect Get a ready-to-paste MCP connector config (URL + key) for Claude/Cursor/Windsurf/Codex/ChatGPT Auto-provisions your memory key on first call
## Limits and safety
- API keys must be sent in the x-api-key header. Query-string keys are rejected.
- /harvest/sync blocks 110–285s scaled by maxQuestions (serpOnly→110s, ≤50→170s, ≤100→230s, 101–200→up to 285s), under the 300s ceiling; maxQuestions is capped at 200.
- /extract-site handles up to 10,000 pages; /map-urls up to 10,000 URLs.
- URL tools only fetch public http/https hosts. Localhost, private IPs, and internal network addresses are blocked.
- Webhook callbacks must be HTTPS public URLs.
## Errors
HTTP Meaning What to do 400 Bad input Missing field, invalid URL, private URL target, or invalid mode. 401 Auth Missing or invalid x-api-key header. 402 Payment The requested operation needs available credits. 429 Limit User already has an active harvest running. 500/503 Upstream Google, YouTube, browser, or transcription provider blocked or timed out. Retry with a cleaner query or lower max value.
---
## X-Ray Attribution Methodology
Canonical URL: https://mcpscraper.dev/docs/xray/attribution
How X-Ray calculates seven observed attribution models and an explicit-weight observed-plus-reported impact projection.
---
## Native Research and CRM Guide
Canonical URL: https://mcpscraper.dev/docs/xray/crm
How MCP Scraper separates sourced Research records, managed CRM relationships, and read-only X-Ray evidence.
---
## X-Ray SaaS Measurement Foundation
Canonical URL: https://mcpscraper.dev/docs/xray/saas
Install one X-Ray tag, preserve acquisition context, define lifecycle events, govern consent, and compare seven attribution models.
---
## Integrations — Put Your AI to Work Across Your Accounts
Canonical URL: https://mcpscraper.dev/integrations
Connect email, calendar, analytics, meetings, ads, and client accounts to your AI. Work now, remember the result in Memory, or repeat it with Scheduler.
Connected work, without the tab shuffle
# Put your AI to work in your email, calendar, analytics, meetings, and ads
MCP Scraper connects your accounts to your AI, so drafting replies, prepping tomorrow's meetings, reading traffic, and tuning ad spend happen right where the work lives — remembered in Memory, repeated on the Scheduler.
Connect your accounts See what your AI can do Private accounts Every connection belongs to the identity that added it. Writes require approval Connecting an account does not turn on actions. Remember the result Save approved evidence into searchable Memory. Repeat exact work Scheduler receives one account and minimum tool grants. Gmail + Resend
## One Tool Allows Your AI to Manage Your Email
Personal inbox, SaaS support, and marketing sends in one place — your AI drafts replies, triages inbound, investigates delivery, and ships broadcasts across Gmail and Resend, and nothing sends until you say so.
Gmail Resend MCP Scraper · connected work You asked
What needs my attention in support, and why did yesterday's launch email bounce?
Gmail triage 3 threads need a reply Resend delivery Bounce evidence inspected Reply drafted No message sent Result
### One support reply is ready
The delivery issue is explained, the customer context is attached, and the proposed response is waiting for your approval.
Draft only · outbound action not called
Gmail triage → Resend delivery evidence → unsent draft
Google Calendar + Zoom
## Your Calendar and Meetings, Prepped Before You Ask
Google Calendar and Zoom in one view — your AI checks tomorrow's schedule, briefs you on who you're meeting, spins up the Zoom link, and books the follow-up, only when you confirm it.
Google Calendar Zoom Gmail MCP Scraper · connected work You asked
Prepare tomorrow's meetings and tell me which one needs a follow-up booked.
Schedule read 3 meetings tomorrow Context assembled Threads and attendees matched Follow-up proposed Awaiting confirmation Result
### Tomorrow is briefed
The relevant history, open questions, and Zoom details sit beside each meeting instead of in three other tabs.
3 briefs · 1 proposed event · 0 events created
Calendar + Gmail + Zoom → meeting brief → Memory receipt
Google Analytics + Search Console
## Your Traffic, Read and Remembered
Google Analytics and Search Console, answered in chat — your AI pulls this week's clicks, spots what dropped, finds the pages losing ground, and logs every check in Memory so trends surface themselves.
Google Analytics Google Search Console MCP Scraper · connected work You asked
What changed in organic traffic this week, and is this a new problem?
GA4 read Organic sessions compared Search Console Losing queries isolated Memory comparison Four prior checks recalled Result
### Three pages are losing ground
The change is compared with prior checks, so the answer distinguishes a one-day wobble from a developing trend.
Saved to Memory · Marketing / Weekly traffic
GA4 + Search Console → prior Memory checks → trend report
Meta Marketing + Ad Libraries
## Your Ad Spend and Their Ads, in One Conversation
Meta Marketing connected, ad libraries watched — your AI reads your campaign performance, pulls the competitor creatives running right now, transcribes their videos, and tells you what's working on both sides of the auction.
Meta Marketing Facebook Ads Video transcription MCP Scraper · connected work You asked
Compare our strongest campaign with the competitor creatives running now.
Owned performance Campaign results inspected Live ad library Current creatives retrieved Video analysis Hooks and claims transcribed Result
### The gap is in the opening hook
Your performance sits beside public creative evidence, with transcripts and sources attached to the recommendation.
5 creatives · 3 transcripts · sources retained
Meta performance → live ad-library evidence → transcript comparison
Connect once. Control every use.
## Useful access without silent authority
OAuth is the handshake, not permission to do everything. Reads, live actions, scheduled work, and Memory imports each keep their own boundary.
- 1 ### Connect the account Approve the provider's OAuth screen. Credentials remain server-side and private to the identity that connected them.
- 2 ### Inspect exact capabilities See which reads exist and which actions can be separately enabled for that provider and account.
- 3 ### Ask now Use approved reads in the current conversation. Writes stay off unless you deliberately enable and grant them.
- 4 ### Remember or repeat Save an approved result into Memory or give Scheduler one exact account and the minimum tools for the recurring job.
All integrations
## Every connected provider, with its real capability status
OAuth-connected and action-ready are different states. All 15 rows show what can actually be granted today.
### Google Analytics
Ready now
Run GA4 reports and metadata reads. Optionally enable property, data-stream, and conversion-event administration.
5 reads 6 actions
### Google Search Console
Ready now
Read verified properties, Search Analytics performance, sitemaps, and URL inspection results, including quota-conscious API-only batches. Scheduled sync can maintain a typed tenant-owned performance table, but batches do not require a database. Property and sitemap changes remain separately gated and destructive batches default to dry-run.
8 reads 8 actions
### Google Drive
Interactive ready
Browse shared drives and bounded file pages; inspect metadata, changes, Docs, Sheets, and small documents. Folder creation and file copy are separately gated. Bulk corpus delivery is still in development.
10 reads 2 actions
### Gmail
Ready now
Read messages, threads, drafts, labels, and filters. Sending remains a separately enabled and explicitly granted action.
9 reads 1 actions
### Google Calendar
Ready now
Read calendars, events, availability, and upcoming schedules. Event creation remains separately gated.
9 reads 1 actions
### Facebook Pages
Ready now
Read Pages, posts, comments, scheduled posts, and videos. Optionally enable approved publishing and moderation actions.
10 reads 9 actions
### Meta Marketing
Permission-aware ready
Inspect and operate campaigns, ad sets, ads, creative media, insights, audiences, catalogs, rules, studies, leads, and brand-safety data. Every mutation is separately gated; effective tools depend on Meta-granted permissions and approved app features.
55 reads 60 actions
### Slack
Ready now
Read channels, messages, threads, reactions, files, and user context. Message sending remains separately gated.
15 reads 1 actions
### Zoom
Ready now
Read meetings, registrants, recordings, transcripts, and users. Meeting creation remains separately gated.
9 reads 1 actions
### LinkedIn
Core ready
Read the connected member profile today. Community Management workflows require a separate approved LinkedIn app.
1 reads 0 actions
### X
Ready now
Monitor posts, mentions, lists, likes, users, and Spaces. Optionally enable posting, follows, likes, bookmarks, and list actions.
12 reads 13 actions
### YouTube
Ready now
Read channels, videos, playlists, comments, and captions. Optionally enable playlist, comment, and video actions.
9 reads 12 actions
### GitHub
Ready now
Read and sync repositories, issues, pull requests, commits, releases, and workflows. Optionally enable exact create, update, merge, run, or delete actions.
27 reads 20 actions
### Resend
OAuth MCP ready
Read email, inbound mail, delivery logs, contacts, broadcasts, templates, and account configuration. Sending and every mutation remain gated; credential, OAuth, and raw editor-session access stay blocked.
33 reads 45 actions
### Xero
OAuth connected
The account connection is configured. Live scheduler tools remain unavailable until the deployed Xero function inventory is enabled.
0 reads 0 actions
## Built for work that lives in other tabs
From client reporting and follow-up emails to ad audits and meeting prep, MCP Scraper puts your AI inside the accounts where that work already happens — yours and your clients'.
### Founders & Operators
Traffic checked, invoices found, the week's meetings prepped, the follow-up drafted — one AI across GA, Gmail, Calendar, and Xero, so Monday morning runs itself before you've opened a tab.
### Agencies & Client Work
Connect each client's Search Console, Analytics, and ad accounts — reporting pulled, anomalies flagged, drafts ready — so the monthly report takes one ask instead of one afternoon.
### Developers & Vibe Coders
GitHub, Slack, and email in the loop — your AI reads the issue, checks the thread where it was decided, and drafts the reply — context assembled without you alt-tabbing to find it.
### Sales & Relationships
Before the call: the last email thread, the LinkedIn page, the calendar history. After it: the follow-up drafted and the next meeting booked — nothing sent or scheduled until you say so.
### Content & Marketing
Your own campaign numbers next to the competitor creatives running right now — performance read, videos transcribed, hooks logged — so every piece you ship is briefed by what's actually working.
### SaaS Support & Email Ops
Inbound triaged, delivery investigated, broadcasts shipped through Resend — your AI works the support queue and the send calendar from chat, escalating only what needs a human.
Pricing
## Connect what you need. Pay for the work it does.
Connections are a small monthly add-on, billed in Credits from your balance. Reads, actions, and scheduled work use the same shared Credits as the rest of MCP Scraper.
Connected account
15,000 Credits/month each
Each active Nango connection is a 15,000-credit/month add-on drawn from your balance; no plan includes a connection.
- Same-integration replacements inherit the current paid period
- Private to the identity that connected it
- Actions remain separately gated
Connect an account Connected usage
2 + 2 Credits
Measured provider work spends shared Credits instead of creating another balance.
- 2 Credits per connected function run
- 2 Credits per provider proxy request
- 5 Credits per compute-second
See the full rate card Scheduled work
75 Credits / run
Each started scheduled occurrence has one base charge and one billing identity.
- Automatic retries are not charged twice
- Agent mode adds 1.5× reported model cost
- History records settled usage
See the Scheduler Private connections · actions gated · Memory and Scheduler ready
## Put your AI inside the work you already do
Start with one account and one job. Add another only when the workflow needs it.
Open Integrations
## Frequently asked questions
The practical details about connection pricing, permissions, Memory, provider limits, and scheduled work.
Does connecting an account enable writes? No. Live actions remain off until deliberately enabled for that account. Scheduled work still needs an exact connection and exact per-tool grant, and destructive provider actions can require additional confirmation or dry-run behavior. How are connected accounts billed? Each active Nango connection is a 15,000-credit/month add-on drawn from your balance; no plan includes a connection. Disconnecting and replacing the same integration during that billing month transfers its paid period instead of charging another 15,000 Credits. One paid period still covers only one active connection. Work through it uses shared Credits: 2 Credits per connected function run, 2 Credits per provider proxy request, and 5 Credits per compute-second prorated from measured milliseconds. The dashboard Credits tab shows the rate card, and History records settled usage. How does connected evidence enter Memory? import_service_connection_to_memory runs exactly one current read tool, labels the provider result as untrusted evidence, redacts credential-bearing fields, writes to a stable server-generated path, and returns a search_ready receipt. It does not paginate or continuously sync an account. What can Gmail and Resend actually do? Gmail provides inbox, thread, draft, label, and filter reads with sending separately gated. Resend connects through mcp.resend.com/mcp and exposes 33 approved reads plus 45 gated actions. Bulk history uses resend_data ; API-key, OAuth-grant, and raw editor administration remain blocked. What are the provider-specific limits? Provider-specific bulk data is available for selected datasets through export_connected_service_data . Search Console uses search_console_performance ; Gmail, Google Calendar, Meta Marketing, Zoom, and Resend have bounded paths with continuations and private artifact delivery when needed. Deterministic Search Console sync maintains one typed gsc_performance_* table per connection, which agents can query and export without calling Google again. What can Search Console batch safely? API-only Search Console batches do not need that table. The connected account supports URL inspection and Search Analytics reads plus action-gated property and sitemap batches. Every item returns its own receipt, and destructive batches default to dry-run with explicit confirmation.
---
## Memory
Canonical URL: https://mcpscraper.dev/memory
One hosted memory for compatible MCP clients: 16 default note vaults, semantic and temporal recall, linked notes, tables, tasks, and CRM records.
One memory for every AI
# Save everything.
Find it anywhere.
MCP Memory saves everything you capture in vaults shaped for each memory—linked notes, data tables, evolving people and deals, tasks with status—so you, your AI, and your team recall it in seconds.
Get a Vault
- Free to start
- Encrypted & private
- Share with permissions you control
## Your memory, wherever you’re working.
Search by meaning or time, follow linked notes, or browse the full workspace. The same hosted account is available to the compatible MCP clients you connect.
- 16 default note vaults, each with a job
- Linked Markdown notes
- Tables for datasets
- Fact history
- Task and CRM records
- Vault-by-vault export
Recall
## Search by meaning, or by when
Ask with the words you remember or a time window. Memory returns ranked notes with their vault and source, so you can follow the evidence instead of trusting a detached answer.
Loading walkthrough… Semantic and temporal recall through a compatible MCP client
Workspace
## Tasks and relationships stay connected
Tasks, calendar entries, people, projects, organizations, and deals live beside the notes that explain them. Move work in the app or update it from a compatible MCP client.
Loading walkthrough… Tasks, people, projects, organizations, and deals
MCP Scraper
## The web, filed into your vault
A supported scrape can deposit its result into Library as a new note. The source stays available for later search and for the Knowledge notes you distill from it.
Loading walkthrough… A scrape deposited into the Library vault
## History
Update a fact and the old value retires with a date, source, and reason, so you can always see what changed and why.
Database preference
Prefers Postgres Prefers Neon Superseded Mar 14 · source: team chat · switched to Neon
## Page diffs
Store a page once, check it again anytime — the diff shows exactly what changed since you saved it, logged to your vault, so watching a competitor's site is a memory, not a chore.
competitor.com/pricing · diff vs. Mar 2 12 Pro plan
− $24/mo, billed monthly
+ $29/mo, annual only
14 Start trial + New: Teams tier
## Issue log & improvement tracker
A vault for what’s broken — add issues directly, take them from teammates, or route them in from a form — and when one’s fixed, mark it resolved while the Improvement Log keeps what changed and whether it worked.
Loading walkthrough… Issue intake and its linked improvement receipt
## Scheduled vault actions
Put your memory on a schedule — twice-daily consolidation, weekly competitor checks, recurring research — actions that run on their own and file the results where they belong.
Loading walkthrough… Scheduled-action review and a successful run receipt
## Sixteen vaults, each with one job
Ideas, Examples and Inspirations, Knowledge, Library, People, Organizations, Deals, Communication, Calendar, Tasks, Projects, Issues, Skills, Improvement Log, Experiments, Sprint — so nothing you save becomes a junk drawer.
Knowledge 19 Library 32 Tasks 19 Improvement Log 45 People 27 +
## Your apps, filed in
Bring in what happened elsewhere — the email thread, the meeting transcript, the calendar's context, the Slack decision — from fifteen-plus connected services, filed and linked with everything else you know.
+9
## Built for everything worth remembering
From client calls and code snippets to competitor research, deal notes, and half-formed ideas, MCP Memory keeps everything you and your AI learn organized, current, and ready to use.
### Founders & Operators
Keep investor notes, product decisions, competitor moves, metrics, and every “why did we do it this way” answered — one memory that knows your whole company.
### Agencies & Client Work
Give every client their own vault — research, deliverables, calls, and decisions separated cleanly — so context switches in seconds and nothing leaks between accounts.
### Developers & Vibe Coders
Save working snippets, error fixes, architecture decisions, and hard-won lessons from the terminal, then have every future session start already knowing them.
### Sales & Relationships
One evolving card per person — every call, deal, promise, and follow-up attached — so “where did we leave it with Sarah” always has an answer.
### Content & Marketing
Store winning ads, PAA research, hooks, drafts, and full competitor sites in a swipe file your AI can actually search and write from.
### Research & Learning
Turn videos into transcripts, articles into linked notes, and lessons into skills — a knowledge base that compounds instead of scattering across tabs.
## Simple plans. One memory.
Start free. Upgrade when your storage and processing needs grow.
### Free
$0 /mo
Start a hosted memory.
- 10 MB storage
- $1 monthly processing cap
- 16 default vaults
- Semantic and temporal recall
Get a vault Most popular
### Pro
$19 /mo
For a memory that works every day.
- 5 GB storage
- Everything in Free
- Background optimization every 12 hours
- Key-scoped sharing
Choose Pro
### Team
Contact
A 50 GB contract for shared work.
- 50 GB contract
- Shared vaults
- Per-agent scoping
- Plan the right usage boundary with us
Contact us
## Frequently asked questions
The practical details about storage, compatibility, optimization, imports, and export.
What is MCP Memory? A hosted memory service for notes, structured records, and datasets. It connects to compatible MCP clients and includes a visual vault workspace. Which AI tools can use it? Compatible MCP clients can connect to the same account. Client capabilities vary, so follow the current connection instructions in your dashboard. Where is my memory stored? Memory is hosted in your account. The installable package connects your client to that hosted service; it is not a separate data store. Can I inspect and export my notes? Yes. You can read, edit, copy, and download notes as Markdown. Export is available one vault at a time. What happens when information changes? Background optimization runs every 12 hours. It refreshes links and search indexes, flags stale notes, resolves fact conflicts by policy, and surfaces ambiguous decisions for review. Can connected accounts import into Memory? Supported connections can write bounded, approved snapshots. Scheduled sync is available only for explicitly supported datasets; other connected accounts remain request-based. Do I need MCP Scraper or Scheduled Actions? No. Memory can be used on its own. MCP Scraper can deposit supported web results, and Scheduled Actions can add repeatable workflows when you choose them. What vaults are included? Every account starts with 16 purposeful note vaults for ideas, sources, knowledge, relationships, work, learning, and improvement. Inbox channels can be created separately for shared messages, and the optional encrypted secure vault is separate from semantic Memory.
---
## Pricing
Canonical URL: https://mcpscraper.dev/pricing
Simple monthly subscriptions with credits included — Starter $12/mo, Growth $40/mo, and Scale $100/mo. Scale customers can add 80,000 credits in $10 increments.
Pricing
# One subscription. Every tool.
Every plan includes the full 315 -tool platform and a monthly Credit balance. Start for $1, then scale the balance and parallelism—not the features you are allowed to use.
Start for $1 View the rate card Starter
$12 / month
For solo builders and side projects. $1 first month
- 80,000 credits / month
- 3 Parallel Browsers
- Every tool, including the live browser
- Integrations available as 15,000-credit/month add-ons
Start for $1 Growth · Most popular
$40 / month
For teams shipping AI features in production.
- 266,667 credits / month
- 10 Parallel Browsers
- Every tool, including the live browser
- Integrations available as 15,000-credit/month add-ons
Get started Scale
$100 / month
For heavy automation and agencies.
- 800,000 credits / month
- 20 Parallel Browsers
- Every tool, including the live browser
- Integrations available as 15,000-credit/month add-ons
Get started Enterprise
Custom
SLAs, invoicing, and priority support.
- Custom volume
- Custom Parallel Browsers
- Every tool, including the live browser
- Integrations available as 15,000-credit/month add-ons
Contact us
Starter is $1 for the first month, then $12/month, and you can cancel anytime. Growth and Scale bill at full price from day one. Credits last three months and are spent oldest-first.
npx -y -p mcp-scraper@latest mcp-scraper-cli billing concurrency checkout Add only what you need
## Connections, capacity, and storage stay explicit.
One Credit balance covers tools, connected-account usage, and scheduled work. Recurring add-ons are listed separately from that usage meter.
15,000 credits/mo each
### Integration connection
Each active Nango-backed provider account is a separate add-on. A same-integration replacement inherits the disconnected connection's paid period for the current billing month. Work costs 2 Credits per function run, 2 per proxy request, and 5 per compute-second, prorated from milliseconds.
$5/month
### Parallel browser packs
Add 2 extra browsers per pack to run more tool calls and live browser sessions at the same time.
75 Credits/run
### Scheduled actions
Each started occurrence costs 75 Credits. Connected usage keeps its normal rates; agent mode also adds 1.5× OpenRouter's reported model cost.
$19/month
### Memory Pro storage
Memory is a separate subscription. Free accounts include 10 MB of storage; Pro raises the limit to 5 GB.
Canonical rate card
## Pay for the work each tool performs.
Operation prices are the same on every plan. A larger plan buys more Credits, not a different per-tool rate.
Operation Credits Billed Notes Active integration connection 15,000/mo per active Nango connection Recurring charge drawn from your Credit balance. A same-integration replacement inherits the disconnected connection's current paid period. Connected function execution 2 per function run Debited from the same Credit balance as the rest of MCP Scraper. Connected provider proxy request 2 per proxy request Each provider request made through the connection is metered. Connected function compute 5 per compute-second Prorated from aggregate compute milliseconds; sub-second work is not rounded to a full second. Scheduled deterministic connection sync 75 base per started occurrence No model charge. Connected function, proxy, and compute usage is added at the rates above. Scheduled agent occurrence 75 base per started occurrence Also adds 1.5× OpenRouter's reported model cost, connected usage, and any separately metered scraper, browser, or media work. SERP Intelligence page snapshot 1 per attempted URL Optional. Requested URL capacity is held before the run; unused capacity is refunded automatically. SERP search 60 per `search_serp` call Returns organic results and Google entity IDs by default; optional same-page local pack, forums, videos, AI surfaces, and What People Are Saying are enabled with flags at the same product price. search_serp and the base capture_serp_snapshot search are billed 60 credits per search. Optional SERP Intelligence page snapshots add 1 credit per attempted URL. PAA harvest 10 per question (+400 credit base) Returns original-query PAA questions with answers and sources plus organic results and Google entity IDs. Optional same-page SERP modules are flag-controlled. Billed 400 credit base + 10 per question actually returned (unused estimate refunded). Page crawl / extract 1 per page Applies to both single-URL extraction and per-page site crawls. Directory or wiki listing creation 10 per new listing Fixed total price for a new Local Sourcebook directory listing or Transparent Commons wiki entity. Sourcebook acquisition is included. Directory or wiki listing edit 2 per existing listing revision Fixed total price for refreshing an existing Local Sourcebook listing or revising an existing Transparent Commons entity. Site URL mapping 5 per mapping operation Flat rate for the full /map-urls call regardless of URL count discovered. YouTube search / channel harvest 2 per call — YouTube transcription 200 base + 2/min of video Flat 200-credit base plus 2 credits per minute of video, reconciled to the real video length after transcription (e.g. a 10-minute video is about 220 credits). Facebook search / ad lookup 7 per call — Maps business search 5 per search Returns up to 50 Google Maps business/profile candidates. Use maps_place_intel to hydrate selected businesses. Maps business lookup 60 per business Base lookup. Reviews billed separately per card at maps_review rate. Maps review 1 per review card Charged after extraction when includeReviews is true. Facebook ad library search 8 per search Browser automation to search Facebook Ads Library by keyword. Google Ads Transparency search 6 per search Browser automation to find advertisers in Google Ads Transparency Center by domain or name. Google Ads Transparency advertiser intel 2 per call Lists and hydrates an advertiser's creatives with image URLs and video references. Google ad video transcription 200 base + 2/min of video Flat 200-credit base plus 2 credits per minute of video, reconciled to the real video length after transcription (e.g. a 10-minute video is about 220 credits). Facebook video / ad transcription 200 base + 2/min of video Flat 200-credit base plus 2 credits per minute of video, reconciled to the real video length after transcription (e.g. a 10-minute video is about 220 credits). Instagram profile content discovery 4 per profile scan Browser extraction of public Instagram profile grid links. Complete history may require a logged-in profile. Instagram media download 4 per post or reel Extracts post text, image URLs, and reel audio/video tracks, with local downloads when the server can write files. Instagram media transcription 200 base + 2/min of video Whisper transcription of selected Instagram audio/video media. Flat 200-credit base plus 2 credits per minute of video, reconciled to the real video length after transcription (e.g. a 10-minute video is about 220 credits). Interactive browser session 120 per minute of use Metered per minute of use for the whole time the browser session is open. Close the session to stop the meter; abandoned sessions are auto-closed after a short idle window. Reddit thread base lookup 30 per thread Base lookup for the post itself. Comments billed separately per comment at reddit_comment rate. Refunded if the thread cannot be retrieved. Reddit comment 2 per comment Charged per comment actually extracted, billed down automatically if the balance runs out mid-thread. Video breakdown (frame-by-frame + transcript) 6,667 per 120 frames (max 480) Full multi-lens video breakdown: samples frames across a video (up to 30 minutes), analyzes each with vision AI, transcribes the audio, then produces summary, pacing/energy, words-per-minute, topic outline, key points, hook analysis, visual style, and a how-to-replicate recipe with a quality-control pass. $1 per 120 frames requested (max 480 = $4); billed down automatically if the video cannot use the requested frames, and refunded fully if the run fails. Trustpilot review harvest 5 per call Base lookup. Reviews billed separately per card at trustpilot_review rate. Refunded if no reviews are found. Trustpilot review card 1 per review card Charged per review actually extracted, billed down automatically if the balance runs out mid-page. G2 review harvest 5 per call Base lookup. Reviews billed separately per card at g2_review rate. Refunded if no reviews are found. G2 review card 2 per review card Charged per review actually extracted (each card carries up to 3 Q&A sections), billed down automatically if the balance runs out mid-page. Page change check 1 per check Same cost as a single page extract — one scrape is performed per check, then compared against your last stored snapshot for that URL.
Rate policy serp-paa-2026-08-11 , effective 8/11/2026 .
The details
## Frequently asked questions.
How are integrations billed?
Each active Nango connection is a 15,000-credit/month add-on drawn from your balance; no plan includes a connection. Disconnecting and replacing the same integration during that billing month transfers the paid period instead of charging another 15,000 Credits. One paid period still covers only one active connection. Work through that connection uses the same shared Credit balance at 2 Credits per function run, 2 Credits per provider proxy request, and 5 Credits per compute-second, prorated from aggregate milliseconds.
How are Scheduled Actions billed?
Scheduling is available on every paid plan. Each started run costs 75 Credits. Deterministic connection syncs also debit their measured connection usage. Agent-mode runs add measured connection usage plus 1.5× OpenRouter's reported model cost. There is no separate scheduling subscription or monthly run quota.
What happens if a scheduled run fails or retries?
If execution never starts, the authorization is voided. Once execution starts, the 75-credit base is settled even if the task later fails. An automatic retry of the same scheduled occurrence reuses its billing identity, so it does not create a second 75-credit charge.
How do credits work?
Every tool call spends Credits based on the work it does — a SERP search is 60 Credits per `search_serp` call, a page crawl is 1 Credit per page, a Maps business lookup is 60 Credits per business, and a live browser session is 120 Credits per minute of use. Connection usage draws from that same balance. Tool access is available on every plan; active integrations are separate 15,000-credit/month add-ons.
Do credits expire?
Yes — credits last 3 months from when they're added, and are spent oldest-first (FIFO). Each billing cycle tops your balance back up with your plan's monthly credit allowance.
Is there a free trial or free tier?
Starter is $1 for your first month, then $12/month, with no separate free tier. Scale customers can buy one-time packs of 80,000 credits in $10 increments; Starter and Growth remain monthly-subscription only.
What are Parallel Browsers?
They set how many tool calls and live browser sessions you can run at the same time. Starter includes 3, Growth includes 10, and Scale includes 20. Each $5/month pack adds 2 browsers on any plan.
Can I change plans later?
Yes. Upgrades charge the prorated difference immediately and add the new plan Credits only after payment succeeds. A failed payment leaves the current plan unchanged.
Starter
## Try the full platform for $1.
No separate free tier. One-time Credit packs are available only on Scale at 80,000 Credits per $10 increment.
Get started
---
## Privacy Policy
Canonical URL: https://mcpscraper.dev/privacy
How MCP Scraper handles account data, per-user OAuth connections, provider data, scheduled actions, retention, security, and deletion requests.
Privacy policy · Effective July 15, 2026
# Your connections belong to you.
This policy explains what MCP Scraper receives when you connect a provider, how your AI or scheduled work can use that connection, and how to revoke access or ask us to delete data.
One user, one grant. Another MCP Scraper customer cannot use your connected account.
Credentials stay server-side. OAuth access and refresh tokens are stored through Nango, not returned to your browser, AI agent, or MCP client.
You stay in control. You can revoke provider access, cancel schedules, delete your MCP Scraper account, or email us for connection-data deletion.
## 1. Scope
This policy applies to mcpscraper.dev, MCP Scraper APIs and MCP servers, the MCP Scraper dashboard, connected-provider features, memory features, and scheduled actions (together, the “Service”). “MCP Scraper,” “we,” and “us” mean the operator of the Service.
When you use the Service for an employer or customer, that organization may control the data and your use. In that case, its privacy notice may also apply. Provider services such as Google, YouTube, Meta, LinkedIn, and X have their own privacy practices.
The Service is not directed to children under 13, and connected-provider and scheduled-action features are intended for adults and authorized business users.
## 2. Data we collect
- Account and support data Email address, password hash, account and subscription status, preferences, support messages, and records needed to administer your account.
- OAuth connection data The provider, connection ID, the provider account identifier or display information returned by the provider, granted scopes, connection status, organization or workspace identifiers, and OAuth access and refresh tokens. We do not ask for or store your provider password.
- Authorized provider data Only data covered by the scopes you grant and the feature you use, such as analytics reports, channels, posts, comments, pages, ad accounts, campaigns, lists, likes, bookmarks, and related metadata.
- Instructions, schedules, and results The action you request, selected account, permitted tools, timing and time zone, run status, provider response, and output returned to you or your selected AI client.
- Service, device, and billing data API requests, timestamps, IP address, browser and device information, error and security logs, connected-account quantities, Nango function/Proxy/compute measurements, usage and Credit receipts, referral or attribution data where enabled, and billing identifiers. Stripe handles full payment-card details directly.
- Content you submit URLs, prompts, files, memory notes, browser-session inputs, and other material you ask the Service to process.
## 3. How we use data
We use data to authenticate you; provide the feature you requested; create, refresh, and validate a connection; execute a user-authorized action or schedule; return results to you or the AI/MCP client you chose; maintain billing; prevent abuse; diagnose failures; provide support; and comply with law.
01 · Connect You choose a provider and approve its OAuth scopes. 02 · Instruct You choose the account, tools, action, and timing. 03 · Run The server uses that connection only for the authorized work. 04 · Revoke You can stop provider access and request deletion.
We do not sell connected-provider data, use it for cross-context behavioral advertising, or use it to train a generalized AI model. We do not let another customer access your connection. We may use aggregated or de-identified operational metrics when they cannot reasonably identify you and provider rules permit it.
Human access to connected-provider data is limited to what is necessary for support you request, security and abuse investigation, legal compliance, or operating the feature. We do not permit routine human reading of restricted Google data.
Our legal bases, where required, are performance of our contract with you, your consent for provider access and directed actions, legitimate interests in securing and operating the Service, and compliance with legal obligations.
## 4. Connected-provider disclosures
### Google APIs and Google Analytics
Depending on the scopes you approve, we may access Google account identifiers and Google Analytics accounts, properties, streams, configuration, conversion-event data, metadata, and reports. We use this information only to show, analyze, create, update, or archive the items you specifically request.
MCP Scraper’s use and transfer of information received from Google APIs adheres to the Google API Services User Data Policy , including its Limited Use requirements. We request scopes in connection with available features, and provider approval may limit which features can be enabled.
### YouTube API Services
MCP Scraper uses YouTube API Services. Depending on the scopes and action, we may access channel, video, playlist, playlist-item, caption, comment, and related metadata, and may create, update, or delete content only from the YouTube account you authorize.
YouTube actions must be clearly identified and expressly directed by you. We do not download or store YouTube audiovisual content through these connected features. Review the YouTube API Services Terms , YouTube Terms of Service , and Google Privacy Policy .
### Meta and Facebook
Depending on approved permissions, we may access the Facebook identity, Pages, posts, comments, reactions, ad accounts, campaigns, ads, creatives, audiences, and insights that you authorize. We use them only to provide the requested Page, content, or marketing workflow and in accordance with the Meta Platform Terms . We do not use Meta data for unrelated profiles or targeting.
### LinkedIn
Depending on approved products and scopes, we may access your basic member identity and permitted organization, Page, post, comment, reaction, and engagement data. We do not sell LinkedIn content, use it for ads or surveillance, or expose it to other customers. LinkedIn functionality and storage are limited by the LinkedIn API Terms of Use ; some actions may be unavailable even after OAuth.
### X
Depending on approved scopes, we may access your X identity, Posts, mentions, lists, likes, bookmarks, follows, Spaces, and related metadata, and may perform actions you separately direct. OAuth authorization alone is not consent to post, like, follow, or take another action. We require an express instruction or an express schedule before a write action and follow the X Developer Agreement and X Developer Policy .
Provider rules control. A requested action may be unavailable, delayed, or refused because of scopes, app review, rate limits, account status, or provider policies. Scheduling does not override a provider’s requirement for specific consent.
## 5. Sharing and subprocessors
We disclose data only as needed to provide the Service, follow your direction, protect the Service, complete a business transaction with appropriate safeguards, or comply with law. Core service providers currently include:
Provider Purpose Data involved Nango OAuth flow, server-side credential storage and refresh, provider API execution Connection tags, provider configuration, scopes, access and refresh tokens, action inputs and responses Vercel Application and API hosting Requests, responses, network and runtime logs Turso / libSQL Application database Account, usage, schedule, and connection-reference records Stripe Payments and subscription management Billing contact, customer and subscription identifiers; Stripe handles payment details Resend Transactional email Email address and message delivery data
If you invoke MCP Scraper from Claude, ChatGPT, Cursor, another AI service, or another MCP client, requested output is returned to that service at your direction. Its terms and privacy policy govern what it does after receipt. Feature-specific browser, compute, transcription, or model providers may process the minimum input needed for a feature you request.
Nango states that Nango Cloud encrypts connection credentials at rest and traffic in transit. See Nango’s security documentation . This does not mean MCP Scraper itself claims Nango’s certifications.
## 6. Retention
We keep account, usage, billing, and support records only as long as reasonably needed for the Service, security, dispute resolution, tax and accounting, and legal obligations. Schedules and their run records remain until deleted, the account is closed, or they are no longer operationally needed.
OAuth tokens are retained through Nango while the connection is active. After you revoke access, request connection deletion, or close your account, we stop using the connection and delete or de-identify provider data according to the applicable provider rule and our backup lifecycle, unless law requires limited retention.
- YouTube authorized data is deleted as soon as possible and no later than 30 calendar days after revocation, unless YouTube permits or law requires retention.
- LinkedIn API content and tokens are deleted promptly upon your deletion request or account closure, subject only to a legal preservation duty.
- For Meta, X, Google Analytics, and other providers, we delete connection credentials and provider data when the connection is deleted, subject to provider rules, legal duties, and short-lived backups.
We may retain non-identifying aggregate statistics and records needed to document a deletion or legal compliance.
## 7. Security
We use administrative and technical safeguards designed for the sensitivity of the data, including HTTPS, server-side secrets, scoped connection identifiers, access controls, logging and monitoring, and vendor security controls. OAuth tokens are not intentionally sent to your browser, AI agent, or MCP client. Nango stores and refreshes those tokens for the server-side connection.
No online service is perfectly secure. Protect your MCP Scraper account and provider accounts, review granted scopes, and contact support@mcpscraper.dev if you suspect unauthorized access.
## 8. Revocation, deletion, and your rights
### Stop a connection
You can revoke MCP Scraper directly in the provider’s connected-app settings: Google and YouTube , Meta/Facebook , LinkedIn , or X . Revocation prevents future authorized calls once the provider processes it, but does not undo actions already completed.
Also cancel or remove any MCP Scraper schedules that use that connection. Use Dashboard → Integrations → Disconnect to delete the Nango connection record, tokens, bindings, and stored provider data and synchronize its recurring Stripe quantity. If dashboard deletion fails, email support@mcpscraper.dev with your MCP Scraper account email and provider name. Never send us your password or token.
### Delete your MCP Scraper account
Use Account → Delete account to cancel active subscriptions, deactivate access, and start the account-deletion workflow. Email support if you also want confirmation that every connected-provider record has been deleted.
### Meta data-deletion instructions
If you arrived here from a Meta data-deletion request, revoke the app in Facebook’s Apps and Websites settings and email support@mcpscraper.dev from your MCP Scraper account address. Include “Meta data deletion” and, if known, the connected Page or ad-account name. We will verify the request, delete the applicable connection and stored Meta-derived data, and confirm completion. Do not include Meta credentials.
### Privacy rights
Depending on where you live, you may request access, correction, deletion, portability, restriction, or an objection to certain processing. You may withdraw consent without affecting earlier lawful processing. We do not sell personal information or share it for cross-context behavioral advertising. Email us to exercise a right or appeal a decision; we may reasonably verify your identity.
Data may be processed in the United States and other countries where our service providers operate. Where required, we rely on contractual or other lawful transfer safeguards.
## 9. Changes and contact
We may update this policy as the Service, providers, or law changes. We will change the effective date and provide additional notice when a material change requires it. If we materially expand how we use connected-provider data, we will request any new consent required before that use.
MCP Scraper privacy contact
support@mcpscraper.dev https://mcpscraper.dev
---
## Scheduling
Canonical URL: https://mcpscraper.dev/scheduler
Put reminders, connected-account reads, recurring agent work, approvals, and results in one governed schedule.
Scheduled actions
# Schedule the outcome. Not the busywork.
Describe recurring work once. The cloud runtime uses a bounded provider sync or a reviewed agent toolset, then stores the result and its progress on your schedule.
Add scheduled actions Explore integrations mcpscraper.dev/scheduled-actions
“ summarize GA4 and YouTube performance every Monday ”
Execution path Scheduled Action → selected GA4 + YouTube reads → Projects vault Google Analytics YouTube reads only Conversions 184 +12% week over week Video views 42.8k 3 videos published Filed to Projects 2026-W28 marketing pulse
Selected account reads and the resulting report are stored with the run status in Memory.
Public-web tools, private memory, and selected OAuth accounts can meet inside one run. Writes remain off until explicitly enabled and granted.
75 credits per started run 1.5× OpenRouter-reported model cost 15,000 Credits per active connection / month 339 tools in the unified MCP catalog Deterministic data pulls
## One occurrence. One scheduled event.
Each occurrence performs a bounded provider slice and stores an exact continuation when more history remains. Internal provider pages do not create extra 75-Credit base events, but their measured proxy requests and compute remain visible usage units.
America/Denver
### Operations data pull
08:00 12:00 16:00
Gmail · Google Calendar · Search Console · Zoom · GitHub · Resend
Scheduled occurrence 1 75-Credit base plus Provider pages measured 2 Credits / proxy request and Function work measured runs + compute milliseconds
Each active Nango connection costs 15,000 Credits/month from your balance. A same-integration replacement inherits the disconnected connection's paid period for the current billing month. Connected work debits 2 Credits per function run, 2 per provider proxy request, and 5 per compute-second, prorated from aggregate milliseconds. The scheduler calls model-free provider adapters directly for supported Gmail, Calendar, Search Console, Zoom, GitHub, and Resend datasets. Search Console runs upsert typed rows into the connection's discoverable gsc_performance_* table so later agents can filter stored history without another Google call. The 75-Credit base covers the started occurrence; agent mode also adds 1.5× OpenRouter’s reported model cost.
Scheduled agent mode can instead receive exact Search Console API-only batch grants for URL inspection, Search Analytics comparison, property management, and sitemap management. Those batches do not write a database; action batches still require the account action switch, and delete batches default to dry-run confirmation.
Resend · deterministic reconciliation
## Download the operating history. Keep sending separate.
A Resend sync is model-free: it pages six approved datasets, checkpoints progress, deduplicates raw records, detects changes, and mirrors the bounded result into the selected vault. A send or delete still requires agent mode, the account action switch, and an exact tool grant.
Connected account Resend · Production official OAuth grant Six datasets
### Sent email · inbound email · logs · contacts · broadcasts · templates
Request logs are the available delivery audit trail; the official MCP does not expose a separate delivery-event history reader.
Bounded occurrence
### 30 provider calls
Each list request asks for 10 records. Oversized individual records stop at 96 KiB, and exact cursors resume unfinished work.
Separate authority
### 33 reads · 45 gated actions
Seven credential, OAuth-administration, raw editor-session, and secret-creating tools remain permanently blocked from the scheduler and external MCP bridge.
One scheduled occurrence creates one 75-Credit base charge. Its function runs, provider requests, and compute are recorded separately at the connected-usage rates, even when the sync spans several provider pages. Progress and provider errors remain attached to the occurrence instead of becoming hidden follow-up jobs.
What it can do
## Monitor. Compare. Act. Remember.
Scheduled work has two execution modes: model-free connected-data syncs and stored agent jobs. Agent mode receives a reviewed web and memory subset plus only its bound provider tools.
Monitor
### Keep watch without reopening dashboards
Re-run searches, pages, reviews, conversations, or account reports on a cadence and keep a dated result from every execution.
Compare
### Turn repeated observations into history
Ask each run to read the previous rows or notes first, then record movement, additions, removals, or a concise change report.
Act
### Use only an explicitly enabled write
Publishing and messaging actions fail closed unless the account switch is on and that exact mutation is granted to the schedule.
Remember
### File the result where the next agent looks
Send narrative reports to a vault and recurring measurements to a table so future work begins with context instead of a blank prompt.
Use cases
## Put recurring work into plain language.
The job can stay read-only, combine several data sources, or use one enabled action. The grant should be as narrow as the outcome.
### Weekly search visibility
Append comparable ranking rows and report movement against prior runs.
Track our position for ‘best HVAC company Denver’ every Monday
### Competitor change watch
Re-scrape selected pages, compare with the stored snapshot, and save a dated change report.
Check these pricing pages every Friday and record what changed
### Monday marketing pulse
Combine approved GA4, Facebook, YouTube, and X reads into one private report.
Summarize our connected marketing accounts every Monday
### Community triage
Read new Facebook comments, YouTube threads, or X mentions and create a prioritized Tasks or Communications entry.
Review new community activity every weekday morning
### Operations digest
Pull approved Gmail, Slack, Calendar, and Zoom activity into one reusable daily digest.
Summarize yesterday's operations activity at 8am
### Resend delivery review
Reconcile sent and received email, request logs, contacts, broadcasts, and templates without spending model turns on provider pagination.
Summarize yesterday's Resend delivery failures every morning
### Approved publishing
Run through the MCP/control API after the account's write switch and exact tool grant are enabled.
Publish this approved update to Facebook and X every Friday The impact
## Build history instead of collecting another snapshot.
Repeated work gets more valuable when every run lands in the same memory shape and the next run can read what happened before.
One setup
Store the task, cadence, timezone, destination, accounts, and tools once.
Public + private context
Combine live web research, previous memory, and selected OAuth accounts.
Comparable records
Use tables for rankings, prices, counts, and scores that should be tracked over time.
Narrow authority
Ownership, connection status, provider policy, and exact tool grants are rechecked.
What every run guarantees
## The contract is visible from setup to storage.
No hidden account pool and no implicit write access. Deterministic and agent-mode runs both start from the stored job, current grants, and a bounded execution budget.
- 1 ### Store the job Description, cadence, start date, time, timezone, and destination are captured before creation.
- 2 ### Wake the runtime The cloud runtime starts the job on its cadence. Your laptop and browser do not need to be open.
- 3 ### Load narrow authority The run receives its destination, selected accounts, and the reviewed tools required for that execution mode.
- 4 ### Execute bounded work Deterministic sync calls exact readers directly. Agent mode can combine reviewed web tools, prior memory, and granted account capabilities.
- 5 ### Store progress Records, continuation checkpoints, and run status are stored. Auth, ownership, and missing-tool failures remain visible and fail closed.
Actual details
## Control is part of the scheduling primitive.
The browser manager handles read grants today. Gated write grants are available through the MCP/control API and require both the account switch and the exact action name.
Cadences One time, daily, weekly, or monthly, with a stored time and timezone. Run price 75 Credits per started occurrence. Connected work also uses 2 Credits per function run, 2 per provider proxy request, and 5 per compute-second, prorated from milliseconds. Deterministic syncs add no model charge; agent mode adds 1.5× OpenRouter's reported model cost. Monthly quota None. Scheduling is included with every paid plan and uses the same Credit balance as the rest of MCP Scraper. Failed runs and retries If execution never starts, the authorization is voided. Once execution starts, the 75-credit base is settled even if the task later fails. An automatic retry of the same occurrence reuses its billing identity and does not add a second base charge. Tool surface The unified catalog contains 339 MCP tools. Agent-mode runs receive the reviewed web and memory subset plus exact bound connection tools; deterministic sync receives only its required readers. Connections Up to 20 exact account connections can be attached to one schedule. Each active Nango connection is a separate 15,000-credit/month add-on; a disconnected connection's same-integration replacement inherits its paid period for the current billing month. Current controls Pause, resume, or delete a schedule. Existing schedules are not edited in place today. Default delivery Results and run status are written to Memory. Messages require an explicitly granted Gmail, Slack, or Resend action. 75 Credits / run · measured connection usage · agent model cost
## Give the recurring work a permanent owner.
No separate scheduling subscription or monthly run quota. Create the job, review its authority, and pause or delete it whenever the work changes.
Open scheduled actions
---
## Scraper
Canonical URL: https://mcpscraper.dev/scraper
252 scraper, connection, and automation tools for search, Maps, connected services, sites, media, live browser sessions, and workflows.
238 scraper, connection, and automation tools
# The data layer for AI agents.
Find data anywhere on the web and hand it to your AI clean and structured. Build knowledge bases, power product features, and move into a live browser when a normal request cannot finish the job.
Start for $1 Read the API docs Live data pull ready Query best hvac company Denver CO 34 PAA questions 10 Organic results 6 AI citations 4 Forum threads Question How much does it cost to replace an HVAC system in Denver? PAA Question Is it cheaper to repair or replace an HVAC system? PAA Source thisoldhouse.com › hvac-replacement-cost PAA source URL Replacing an HVAC system in Denver runs about $7k–$12k installed, depending on size and SEER rating… AI Overview Citation energy.gov › hvac-rebates AI Overview source Best HVAC Companies in Denver — Forbes Home Organic · forbes.com Result #2 Top 10 HVAC Contractors in Denver, CO — Angi Organic · angi.com Result #3 HVAC Contractors — Denver, CO | BBB Organic · bbb.org Bell Plumbing & Heating — 4.8★ (1,204 reviews) Map pack Competitor Comfort Solutions — 4.6★ (832 reviews) Map pack Entity cid 12407… · Knowledge Graph MID Entity IDs HVAC Replacement Cost Explained (12:04) SERP video carousel Channel This Old House · 890K views SERP video carousel Anyone replace their HVAC system recently? What did it cost? — r/HomeImprovement Forum · reddit.com Thread HVAC quotes way higher than expected — Denver — r/personalfinance Forum · reddit.com 238 scraper and automation tools 10,000 pages per crawl 150 People Also Ask questions per query Live browser watch and takeover Videos and ads
## Every video and ad account, structured.
Explore YouTube channels and search, Facebook and Google Ad Libraries, and video transcription. Pick a surface and inspect the structured result.
mcpscraper.dev/youtube/harvest — mode: channel, @hvacrschool H HVAC School @hvacrschool · 1.28M subscribers · 386 videos ▶ 14:32 How to Choose the Right HVAC System for Your Home 284K views · 3 months ago ▶ 9:18 HVAC Maintenance Checklist — Spring Tune-Up Guide 142K views · 6 months ago ▶ 21:07 Heat Pump vs Gas Furnace: Which Saves More in 2025? 521K views · 1 year ago ▶ 11:44 R-410A Phase-Out: What Technicians Need to Know 98K views · 2 months ago ▶ 18:56 Refrigerant Recovery: Step-by-Step for Beginners 67K views · 4 months ago ▶ 16:22 Why HVAC Systems Fail: Top 10 Root Causes Explained 310K views · 8 months ago Google Maps
## Full business intelligence, not just a pin.
Retrieve services, areas served, hours, reviews, and entity IDs for a known business—or search up to 50 ranked candidates for any category and city.
mcpscraper.dev/maps/place Elite Roofing Roofing contractor 4.8 ★ (312 reviews) 4210 Federal Blvd, Denver, CO 80211 (303) 555-0142 Open · closes 6pm Services Roof Replacement Roof Repair Storm Damage Inspection Gutter Installation Areas served Denver Aurora Lakewood Westminster cid 8823019471… · ready for AI Overview / Knowledge Graph matching
One call returns the full profile — services, areas served, hours, and entity IDs ready for AI/Knowledge Graph matching.
Websites
## Crawl it, audit it, or capture exactly what you need.
Run a technical SEO audit across a site, then extract screenshots, schema, images, and clean HTML, JSON, or Markdown from individual pages.
Full-site audit
audit_site example.com · 1,284 pages 1,284 Pages crawled 37 types Issues found 18,402 Internal links 512 Images Issue Pages 🔴 Broken internal links (404) links.brokenInternal 23 🔴 Pages returning 5xx errors response.error5xx 4 🟠 Missing page title title.missing 11 🟠 Missing H1 h1.missing 19 🟠 Set to noindex indexability.noindex 8 🟠 Missing canonical tag canonical.missing 27 🟡 Duplicate title title.duplicate 34 🟡 Duplicate meta description meta.duplicate 41 🟡 Thin content (under 200 words) content.thin 52 🟡 Images missing alt text images.missingAlt 88 🟡 Missing schema markup schema.missing 63 🟡 Title longer than 60 chars title.tooLong 29
Per-page extraction
mcpscraper.dev/extract-url example.com — full page, 1440×900 Mobile viewport also available.
Full-page screenshots, desktop or mobile viewport.
Video analysis
## Understand a video frame by frame.
Sample frames, analyze them with vision, and transcribe the audio to understand pacing, hooks, visual style, and the production choices behind the result.
0:00 0:10 0:20 0:30 0:40 0:50 1:00 1:10 1:20 1:30 480 max frames $1 per 120 frames 30 min longest video supported Hook
What grabs attention in the first 3 seconds, and why it works.
Pacing & energy
Cut frequency, scene length, and energy curve across the video.
Visual style
Color grading, framing, on-screen text patterns — the recognizable look.
Replicate it
A step-by-step recipe for shooting something in the same style.
Needs a direct video file URL (.mp4/.webm/.mov) — resolve a YouTube, Facebook, or Instagram link to its direct media URL first.
What people build
## A live data backbone for whatever you are building.
From one compatible MCP client to a complete SaaS product, MCP Scraper can sit beneath the workflow whenever it needs fresh data from the web.
reddit.com/r/SEO r/ r/SEO Agent reading
##### Which scraper actually gets past Cloudflare?
author: u/seo_mike sentiment: positive ↑ 142 upvotes
Give agents a real browser to log in, click, and read pages nothing else can reach — watch it work live, or take over when it needs a human.
Escalation
## When a normal scrape stops, the workflow keeps moving.
Start with a direct request. If the site blocks it, escalate into an agent-driven browser that can navigate the page and return structured data.
Request Cloudflare · CAPTCHA Browser takes over Structured data Direct scrape → hits a wall → a real browser clears it → structured data, every time. Watch live or take over yourself. Live browser
## Automated when it can be. Drivable when it needs you.
Watch a session live, take over the mouse for a human step, record a replay, reuse saved profiles, and load the Chrome extensions the job requires.
mcpscraper.dev/agent/sessions checkout-flow · watching live
Every session gets a watch link. Take the mouse yourself whenever the agent needs a human, then hand it back.
Use cases
## Choose the web workflow you are building.
See the exact setup, output, and proof for two common ways people connect MCP Scraper.
For agent builders
### Web scraping for AI agents
Search, scrape, map, and recover in a hosted browser with inspectable results.
See the AI-agent workflow → For MCP clients
### Web scraping MCP server
Connect one remote server and expose typed web-data tools to a compatible client.
See the MCP-server workflow → Pricing
## Simple subscriptions with credits included.
Every plan includes credits, parallel browser capacity, and all 238 scraper, connection, and automation tools. Credits last three months.
Starter
$1 first month
Then $12 per month. A practical starting point for individual agents and prototypes.
- 80,000 credits per month
- 3 parallel browsers
- All 238 tools and live browser
Start for $1 Growth
$40 / month
More throughput for products and workflows that rely on live web data every day.
- 266,667 credits per month
- 10 parallel browsers
- All 238 tools and live browser
Get Growth Scale
$100 / month
More throughput for products and workflows that rely on live web data every day.
- 800,000 credits per month
- 20 parallel browsers
- All 238 tools and live browser
Get Scale
Active integrations are 15,000 Credits/month each, drawn from your balance. Each $ 5 /month pack adds 2 parallel browsers. Contact us for volume, SLA, or invoicing needs.
Works wherever you do
## Bring the same tools to every surface.
No replacement workflow. Use a normal tool call wherever your AI already runs.
Claude Desktop and Code
One connector, every tool, zero per-tool setup.
Compatible MCP clients
Standard MCP lets the same tools travel with your agent.
Dashboard
Run tools by hand and inspect the result without writing code.
API and exports
Use JSON, Markdown, or CSV in the stack you already have.
One command connects it all
Install the current package, then add it to your compatible MCP client.
install.sh npx -y -p mcp-scraper@latest mcp-scraper Start with the whole toolkit
## Give your agent the live web.
Every scraper, connection, automation, and browser surface in one account.
Start for $1
---
## Terms of Service
Canonical URL: https://mcpscraper.dev/terms
Plain-language terms for MCP Scraper accounts, connected services, OAuth permissions, user-directed schedules, provider rules, billing, and acceptable use.
Terms of service · Effective July 15, 2026
# Clear rules for connected work.
MCP Scraper can read public web data, connect accounts you authorize, and run work on a schedule you set. These terms explain the responsibilities that come with that power.
Your account, your connection. Only connect accounts you are authorized to use.
Your instruction starts the work. A schedule is an instruction to run later, subject to provider-specific consent rules.
Provider rules still apply. OAuth does not guarantee that every read, write, or delete action is permitted.
## 1. Agreement
These Terms are a binding agreement between you and the operator of MCP Scraper. They apply to mcpscraper.dev, our APIs and MCP servers, dashboard, memory, connected-provider features, and scheduled actions (the “Service”). By creating an account, using the Service, or authorizing a connected provider, you agree to these Terms and our Privacy Policy .
You must be at least 18, able to form a contract, and authorized to act for any organization or provider account you connect. If you do not agree, do not use the Service.
## 2. What the Service does
MCP Scraper provides web-data tools, APIs, memory tools, connected-provider tools, and workflows that can be invoked directly, through an AI/MCP client, or on a schedule. Features, limits, prices, and available integrations may change.
Connected actions depend on OAuth scopes, provider app review, provider account permissions, rate limits, service availability, and provider policies. A connection marked “connected” means an authorization exists; it does not mean every possible action is approved or available.
We may add, change, limit, or discontinue a feature. We will try to give reasonable notice of a material paid-feature change when practical.
## 3. Accounts and security
Provide accurate account information and keep your MCP Scraper credentials, API keys, shared links, and devices secure. You are responsible for activity under your account unless you promptly report unauthorized use.
Do not share another person’s OAuth connection or try to access a connection assigned to another MCP Scraper user. Each user must complete their own OAuth grant unless the provider expressly supports an organization-level connection and the organization authorizes it.
Contact support@mcpscraper.dev if you believe an account, API key, or connection is compromised.
## 4. Connected services
When you select “Connect,” you authorize the named provider to give MCP Scraper the scopes shown in its consent screen. OAuth tokens are stored server-side through Nango. We do not need your provider password, and you must not send it to us.
You represent that you are authorized to access the connected account and its data. You are responsible for choosing the correct provider account, reviewing scopes, complying with workplace policies, and ensuring that any content or person affected by an action can lawfully be processed.
You may revoke access in the provider’s settings. Revocation does not necessarily undo an action already completed. See the revocation and deletion instructions for connection deletion.
## 5. Scheduled and write actions
Creating a schedule is your instruction to run the described work at the selected time using the selected account and allowed tools. You must review the action, destination, audience, timing, and account before enabling it. MCP Scraper may execute that instruction later without another click only where provider rules allow.
OAuth is not action consent. When a provider requires separate, specific, or contemporaneous consent, MCP Scraper may ask for confirmation, restrict scheduling, or refuse the action even though the account is connected.
Posting, commenting, following, liking, changing settings, creating ads, spending funds, or deleting content can have public or irreversible consequences. You are responsible for the instructions and inputs you approve. We may add safety checks, spending limits, previews, or confirmation requirements.
Schedules can fail because of expired credentials, revoked scopes, app-review limits, quota or rate limits, provider outages, invalid input, moderation, or changes to a provider API. Monitor important work and keep an independent recovery plan. The Service is not a guaranteed delivery, records-management, emergency, or safety system.
## 6. Acceptable use
You may not use the Service to:
- break law, infringe rights, breach a contract, or access an account or data without authorization;
- send spam, create inauthentic engagement, manipulate a platform, impersonate someone, or evade provider review, rate limits, suspensions, or security controls;
- conduct surveillance, discriminatory profiling, unlawful background checks, or sensitive eligibility decisions using provider data;
- collect or expose passwords, tokens, private messages, personal data, or confidential information without a lawful purpose and required consent;
- use provider data for unrelated advertising, data brokerage, resale, or model training where provider rules prohibit it;
- upload malware, interfere with the Service, test vulnerabilities without written permission, or burden systems unreasonably; or
- use an automated action in a way that violates Google, YouTube, Meta, LinkedIn, X, or another provider’s terms.
We may block an action, connection, schedule, or account when reasonably necessary to protect users, providers, the Service, or comply with law.
## 7. Provider terms
Connected services are independent third parties. Their terms, privacy policies, product rules, API limits, and enforcement decisions apply in addition to these Terms. We do not control them or promise continued access.
### Google and YouTube
Your use of Google-connected features is subject to applicable Google API Terms . By using MCP Scraper’s YouTube-connected features, you also agree to be bound by the YouTube Terms of Service . The Google Privacy Policy describes Google’s practices. YouTube write actions require your specific direction and may not be automated where YouTube rules prohibit it.
### Meta and Facebook
Meta-connected use is subject to the Meta Platform Terms and applicable Meta product terms. Permissions, marketing data, Pages, and publishing features may require Meta app review and business authorization.
### LinkedIn
LinkedIn-connected use is subject to the LinkedIn API Terms of Use and approved product terms. Those rules restrict storage, redistribution, advertising uses, and automated posting. We may disable scheduling or storage for LinkedIn actions even if a template exists.
### X
X-connected use is subject to the X Developer Agreement , X Developer Policy , Automation Rules, and other incorporated rules. You must provide express and informed instruction for actions; signing in or completing OAuth alone is not enough.
## 8. Your content and data
You keep ownership of content and data you submit. You give us a limited, worldwide license to host, copy, transmit, transform, and process it only as needed to provide, secure, support, and comply with law for the Service. This license ends when the content is deleted from active systems, subject to backups and legal retention.
You do not gain ownership of provider data, provider APIs, or third-party content. You must have all rights and permissions needed for your instructions. Results may be incomplete, outdated, inaccurate, or subject to third-party rights; verify important outputs before acting on them.
If you send output to an AI or MCP client, you direct that transfer and are responsible for the receiving service’s settings and terms.
## 9. Billing
Prices, credits, included usage, renewal terms, and taxes are shown at purchase or in your plan. Paid subscriptions renew until canceled. Usage-based charges and provider charges may be separate. You authorize Stripe and us to charge the payment method for amounts you approve.
Each active Nango-powered connected account adds a US $3 monthly recurring quantity to an active paid plan subscription; paid plans do not include a connection. Connected activity is also deducted from your shared Credit balance at the published rate revision: 2 Credits per function execution, 2 Credits per Nango Proxy request, and 5 Credits per compute second calculated from measured milliseconds. OAuth connect and reconnect do not themselves consume Credits. Current quantities, receipts, and rates appear in Integrations, Credits, History, Billing, and the machine-readable rate API.
Disconnecting an account removes it from future recurring quantities after synchronization; Stripe may prorate the subscription item. Connected work is unavailable without an active paid plan. Unless law requires otherwise or the purchase screen says differently, fees already incurred are non-refundable. Canceling stops future renewal but does not reverse usage already consumed or provider actions already executed.
## 10. Disclaimers and liability
The Service is provided “as is” and “as available.” To the extent law allows, we disclaim implied warranties of merchantability, fitness for a particular purpose, non-infringement, and uninterrupted or error-free operation. We do not guarantee provider approval, data accuracy, job completion, uptime, revenue, rankings, or business outcomes.
To the extent law allows, MCP Scraper and its operator will not be liable for indirect, special, incidental, exemplary, punitive, or consequential damages, lost profit, lost data, provider enforcement, or the effect of an action you instructed. Our aggregate liability for a claim is limited to the greater of US $100 or the amount you paid us for the Service during the 12 months before the event giving rise to the claim.
Some jurisdictions do not allow all exclusions or limits, so these provisions apply only to the maximum extent permitted. Nothing limits liability that cannot legally be limited.
You will defend and indemnify MCP Scraper and its operator against third-party claims arising from your content, instructions, connected accounts, unlawful use, or breach of these Terms, except to the extent caused by our own unlawful conduct.
## 11. Suspension, deletion, and changes
You may stop using the Service, cancel paid plans through Billing, revoke provider access, and use Account → Delete account . Account deletion does not undo completed provider actions and may preserve limited billing, security, or legal records.
We may suspend or terminate access for nonpayment, security risk, provider requirement, unlawful or abusive use, material breach, or when needed to protect others. Where practical, we will explain the reason and allow a chance to correct it.
We may update these Terms by posting a new effective date. If a material change requires notice or consent, we will provide it. Continuing to use the Service after the effective date means you accept the updated Terms to the extent law permits.
If one part of these Terms is unenforceable, the rest remains in effect. A delay in enforcement is not a waiver. These Terms and any written order form are the entire agreement about the Service, and an order form controls if it expressly conflicts.
## 12. Contact
MCP Scraper support and legal contact
support@mcpscraper.dev https://mcpscraper.dev
---
## Use Cases
Canonical URL: https://mcpscraper.dev/use-cases
Explore how MCP Scraper helps you research customers and competitors, create content, and prepare client work with AI.
---
## Google Maps Scraper for AI Research
Canonical URL: https://mcpscraper.dev/use-cases/google-maps-scraper
Get Google Maps business details and reviews in your AI. Research customers, compare competitors, and prepare better content and client work.
---
## Web Scraping for AI Agents
Canonical URL: https://mcpscraper.dev/use-cases/web-scraping-for-ai-agents
Build AI agents that search, crawl, map, and navigate the live web, then return structured evidence, stable IDs, and inspectable artifacts.
MCP Scraper
# Web Scraping for AI Agents
Give your AI agent useful web data.
Search, scrape, and browse in one place.
Search the web, scrape one page or a whole site, collect data from Maps and social platforms, and open a real browser when the job needs one.
Start for $1 Explore all 238 tools
- 238 tools
- 10,000 pages per crawl
- Live browser watch & takeover
## Everything your agent needs to work with the web.
Use one toolkit to find information, collect it, check the sources, and keep going when a normal scraper cannot finish the job.
- Search
- Scrape
- Map
- Crawl
- Google Maps
- Reddit
- YouTube
- Ad libraries
- Live browser
Actual outputs
## Explore four real outputs.
Maps, query fan-out, hosted browser, and site mapping each have their own three-image carousel. Swipe on touchscreens or use the arrows.
### Google Maps results
The request, ranked businesses, and returned business fields.
Full result
### Query fan-out
The prompt, eight searches, source counts, and returned answer.
Full result
### Hosted browser session
The session record, tool sequence, target, capture state, and close state.
Full session
### Site map
The target, route totals, status codes, and discovered URLs.
Full result
Four simple steps
## How MCP Scraper works
Tell it what to collect, choose the right tool, get the result, and check the sources.
- 01 Ask Say what source to use, what to collect, and what you want back.
- 02 Collect Search, scrape, crawl, use Maps, or open the hosted browser.
- 03 Get results Receive structured data, Markdown, screenshots, transcripts, or saved files.
- 04 Check Review the sources, retry the job, or continue in a live browser.
## Collect data from websites, Maps, social platforms, and more.
Search the web, scrape one page or a whole site, look up businesses on Maps, collect posts and videos, review public ads, or control a browser—all with the same account.
Search & sites Maps Social Media Browser +
## Use the results anywhere.
Use MCP Scraper from an MCP client or the dashboard. Send the JSON, Markdown, CSV files, screenshots, transcripts, or saved results straight into your product or workflow.
MCP clients Dashboard API Exports
## What you get
The tools your agent needs to find, collect, check, and reuse web data.
### Find the right source
Search websites, Maps, Reddit, YouTube, ad libraries, or any other source the job calls for.
### Get structured results
Choose the fields you need and get clean records, Markdown, files, screenshots, or saved results.
### Keep the source links
See where every result came from so you can check it, share it, or run the job again.
### Match the same business
Use stable IDs such as Google CIDs to recognize the same business across different searches.
### Scrape a whole site
Map or crawl up to 10,000 pages instead of opening them one at a time.
### Switch to a browser
Open a hosted browser when a page needs clicks, navigation, or a human sign-in.
## Choose a plan.
Every plan includes the 238 scraper, connection, automation, and live-browser tools. Credits remain available for three months.
### Starter
$1 first month
Then $12 per month. A practical start for an individual agent or prototype.
- 80,000 credits per month
- 3 parallel browsers
- All 238 tools and live browser
Start for $1 Most popular
### Growth
$40 /month
More throughput for products and workflows that use live web data every day.
- 266,667 credits per month
- 10 parallel browsers
- All 238 tools and live browser
Get Growth
### Scale
$100 /month
More throughput for products and workflows that use live web data every day.
- 800,000 credits per month
- 20 parallel browsers
- All 238 tools and live browser
Get Scale
Active integrations are 15,000 credits per month each, drawn from your balance. Each $ 5 /month pack adds 2 extra browsers.
## Frequently asked questions
The practical details about agent access, collection surfaces, browser escalation, outputs, and setup.
What does web scraping for AI agents mean? It means giving an agent tools that can find and collect current public-web information, then return it as usable text or structured data instead of making the agent reason over raw browser noise. Which AI tools can use MCP Scraper? Compatible MCP clients can connect to the same hosted account. You can also use the dashboard and supported API or export paths when the workflow does not run inside an MCP client. What can an agent collect? The current toolkit covers search, individual pages, full sites, technical audits, Google Maps, Reddit, YouTube, public ad libraries, media transcription, connected services, and live-browser workflows. What happens when a normal request cannot finish? A workflow can move into a hosted browser session. You can watch the session, take over for a human step, and reuse a saved profile when the job requires an authenticated state. Does MCP Scraper bypass every website? No. Site behavior and access rules vary. MCP Scraper provides multiple collection surfaces and a live-browser recovery path, but it does not promise universal access or a guaranteed bypass. What formats can the result use? Depending on the tool and workflow, results can be returned as structured fields, JSON, Markdown, CSV, screenshots, transcripts, or saved artifacts that a later step can inspect. How do I get started? Create an account, choose your client or API path, and follow the current connection instructions in the dashboard. The Starter plan is $1 for the first month and then $12 per month.
---
## Web Scraping MCP Server
Canonical URL: https://mcpscraper.dev/use-cases/web-scraping-mcp-server
Connect one web scraping MCP server to search, scrape pages, map sites, collect platform data, and use a hosted browser from your AI client.
MCP Scraper
# Web Scraping MCP Server
Connect your AI to the web once.
One server. Several web-data jobs.
Add one remote MCP server to your client. Then ask it to search, scrape a page, map a site, collect platform data, or open a browser.
Start for $1 See setup instructions
- 238 tools
- 10,000 pages per crawl
- Live browser watch & takeover
## One connection. Several web-data jobs.
Your AI sees typed tools and picks the one that fits the request. You get the result back with fields, sources, status, or a saved artifact you can inspect.
- Search
- Extract a page
- Map a site
- Crawl a site
- Google Maps
- Reddit
- YouTube
- Ad libraries
- Hosted browser
Actual outputs
## See four real server outputs.
Tool discovery, page extraction, site mapping, and browser recovery each have their own three-image carousel. Swipe or use the arrows.
### Tool discovery
The server catalog, source groups, and one typed tool definition.
Tool catalog
### One-page extraction
The returned title, heading outline, content fields, source, and saved report.
Full result
### Site mapping
The target, route totals, HTTP status summary, and returned URLs.
Full result
### Hosted browser
The recorded session, call sequence, returned page state, and privacy fields.
Full session
Four simple steps
## How the connection works
Connect the server, ask for the result, let the client call the right tool, and inspect what came back.
- 01 Connect Add the remote server to a compatible MCP client.
- 02 Ask Describe the source, fields, and result you need.
- 03 Run The client calls the matching typed tool.
- 04 Check Review the fields, URLs, status, or saved artifact.
## Collect from the source the job calls for.
Use websites, search, Maps, Reddit, YouTube, public ad libraries, media tools, or a hosted browser without adding a different MCP server for every source.
Websites Search Maps Social Browser
## Get a result you can use next.
Return structured fields, Markdown, source URLs, status codes, screenshots, transcripts, CSV files, or saved artifacts to the same conversation or downstream workflow.
JSON Markdown URLs Media Artifacts
## What the server gives you
The practical pieces needed to connect an AI client to live web data.
### One connection
Add the remote server once, then use the same account from compatible MCP clients.
### Typed tools
Each operation declares its inputs, so the client can choose and call it directly.
### Useful results
Get content, fields, URLs, status codes, screenshots, transcripts, or saved artifacts.
### Source-specific data
Use dedicated tools for Maps, Reddit, YouTube, public ads, search, and websites.
### Small and large jobs
Extract one page, map a site, or crawl up to 10,000 pages.
### Browser recovery
Open a hosted browser when a job needs navigation, interaction, or a human step.
## Choose a plan.
Every plan includes all 238 scraper, connection, automation, and live-browser tools. Credits remain available for three months.
### Starter
$1 first month
Then $12 per month. A practical start for one person or a prototype.
- 80,000 credits per month
- 3 parallel browsers
- All 238 tools and live browser
Start for $1 Most popular
### Growth
$40 /month
More throughput for products and workflows that use live web data every day.
- 266,667 credits per month
- 10 parallel browsers
- All 238 tools and live browser
Get Growth
### Scale
$100 /month
More throughput for products and workflows that use live web data every day.
- 800,000 credits per month
- 20 parallel browsers
- All 238 tools and live browser
Get Scale
Active integrations are 15,000 credits per month each, drawn from your balance. Each $ 5 /month pack adds 2 extra browsers.
## Frequently asked questions
The practical details about MCP, tool coverage, returned data, browser recovery, limits, and setup.
What is a web scraping MCP server? It is a server that exposes web-collection tools through the Model Context Protocol. A compatible AI client can discover those tools, call one with typed arguments, and use the returned result in the conversation or workflow. How is this different from a scraping API? An API is usually wired into an application by a developer. MCP gives compatible AI clients a standard way to discover and call the tools. MCP Scraper also provides dashboard, API, and export paths when MCP is not the right surface. Do I need a separate server for every source? No. The same MCP Scraper connection includes tools for websites, search, Maps, Reddit, YouTube, public ad libraries, media, and hosted-browser workflows. What does the server return? The exact response depends on the tool. Results can include structured fields, JSON, Markdown, URLs, status codes, screenshots, transcripts, CSV files, or saved artifacts. What happens when a normal scrape cannot finish? A workflow can move into a hosted browser session. You can watch it, take over for a human step when needed, and keep the session inside the same broader workflow. Does it bypass every website? No. Websites and access rules vary. MCP Scraper provides several collection routes and a browser option, but it does not promise universal access or guaranteed bypass. How do I start? Create an account, open the current setup instructions, and add the remote MCP connection to a compatible client. The Starter plan is $1 for the first month and then $12 per month.
---
## X-Ray Attribution
Canonical URL: https://mcpscraper.dev/xray
Measure customer journeys with one site tag, seven observed attribution models, privacy controls, and separately labeled customer-reported influence.