How to Set Up Context.dev MCP in Cursor and Claude

Q: Does every tool call retrieve fresh content?

Some operations can return cached data. For web-scrape-markdown, the default cache allowance is one day. Set maxAgeMs: 0 when you need a fresh scrape and inspect the returned cache metadata.

TL;DR

Connect to the hosted Context.dev MCP server at https://mcp.context.dev/mcp using Streamable HTTP and browser-based OAuth.
In Cursor, add the URL to mcp.json. In Claude, connect through the connector directory or add a custom remote connector. In Claude Code, use claude mcp add --transport http.
Use web-search to discover sources, web-scrape-markdown to read a page, web-crawl to read linked pages, and web-extract for data shaped by a JSON Schema.
The hosted connection requires no Context.dev npm package, local scraping process, or API key pasted into your client configuration.

We checked this guide against the authenticated production server on September 21, 2026. Its tools/list response exposed 38 tools. We also ran the search, Markdown, and structured-extraction requests shown below against the live endpoint.

What Context.dev MCP does for Cursor and Claude

Context.dev gives your AI client tools for retrieving current web and company data. The client discovers the tools and their input schemas, the agent selects an operation, and the hosted server executes it through Context.dev.

Context.dev manages page retrieval, JavaScript rendering, and scraping infrastructure. Your agent receives readable Markdown, page metadata, or structured data it can use in a research answer or development task. You can inspect the tool call and its source URLs in the conversation.

The live server exposes separate operations for different jobs:

Task	MCP tool	What to request
Find relevant websites	`web-search`	A query, optional domain filters, and a result count
Read a known page	`web-scrape-markdown`	A URL and content-selection options
Inspect page markup	`web-scrape-html`	A URL whose HTML structure matters
Discover a site's URLs	`web-scrape-sitemap`	A domain and optional URL filters
Read several linked pages	`web-crawl`	A starting URL with page, depth, and time limits
Extract specific fields	`web-extract`	A URL, JSON Schema, and extraction instructions
Research a question into JSON	`web-answers`	A research task and optional output format
Retrieve company branding	`get-brand` or `brand-retrieve-unified`	A domain for a visual profile, or a supported identifier for raw data
Parse a document	`parse-document`	File bytes encoded as Base64
Process a large URL collection	`submit-batch`	An asynchronous scraping or crawling job

The server also includes tools for recurring monitors, batch results, company news, design information, and account request logs. Choose the smallest operation that answers the question: reading one known page usually starts with web-scrape-markdown.

Before you connect

You need a Context.dev account, enough available credits for the operations you want to run, and a current MCP-capable client. In a managed workspace, your administrator may need to allow the connector.

The official MCP setup guide uses OAuth. Your client opens a browser, you sign in to Context.dev and authorize access, and the client manages the resulting connection. Keep the full server URL, including /mcp.

Set up Context.dev MCP in Cursor

Add the following entry to .cursor/mcp.json for one project, or ~/.cursor/mcp.json for all your projects. Preserve any other servers already inside mcpServers.

{
  "mcpServers": {
    "context": {
      "url": "https://mcp.context.dev/mcp"
    }
  }
}

Open Cursor's MCP controls in Customize, enable context, and complete the authentication prompt. If the configuration has not appeared, refresh the client or restart Cursor. Confirm that Context.dev tools are available before testing a prompt.

Cursor supports remote Streamable HTTP servers and OAuth. Its MCP documentation covers configuration locations, tool controls, and organization policies.

You can also use the official Context.dev Cursor plugin, which packages the MCP connection with guidance for using Context.dev. Choose one installation path to avoid registering the same server twice.

Set up Context.dev in Claude

Claude on the web and Claude Desktop

Open the Context.dev connector listing, select Connect, and complete the Context.dev sign-in and authorization flow. Enable Context.dev in the conversation's connector controls before asking it to fetch data. The Context.dev Claude guide walks through this connection.

For a manual setup, open Customize → Connectors, select + → Add custom connector, and enter:

Name: Context.dev
URL: https://mcp.context.dev/mcp

Complete OAuth when prompted. This remote-connector flow works in Claude's web and desktop apps; organization policies can affect availability. See Claude's connector instructions for current controls.

Claude Code

Run this command to make the server available across your projects:

claude mcp add \
  --transport http \
  --scope user \
  context \
  https://mcp.context.dev/mcp

Start Claude Code, run /mcp, select context, and authenticate in the browser. You can inspect configured servers from your terminal with:

claude mcp list

For a shared project configuration, use --scope project instead of --scope user. Claude Code writes the remote server entry to .mcp.json:

{
  "mcpServers": {
    "context": {
      "type": "http",
      "url": "https://mcp.context.dev/mcp"
    }
  }
}

Keep "type": "http" in the Claude Code configuration. Each teammate authenticates their own connection. Claude Code's MCP documentation explains scopes and authentication.

Verify the connection with one page

Start a new conversation and ask:

Use Context.dev's web-scrape-markdown tool to read https://example.com.
Return the page title and source URL, and tell me which tool you called.
Use the connected tool rather than answering from memory.

Inspect the tool invocation. Some clients add a server prefix to the displayed name; the underlying Context.dev tool is web-scrape-markdown.

The following JSON is the params object for an MCP tools/call request. The examples throughout this guide use this same format. Your MCP client handles the protocol connection and authentication.

{
  "name": "web-scrape-markdown",
  "arguments": {
    "url": "https://example.com",
    "useMainContentOnly": true,
    "includeLinks": true
  }
}

Our live call returned success: true, Markdown content, the title Example Domain, and a final URL of https://example.com/. The response also included cache_metadata and a request_id.

A written answer alone does not verify the connection. Confirm that the client invoked the Context.dev tool and received a successful result. If the agent uses another provider or answers from memory, check whether Context.dev is enabled and whether a tool approval is pending.

Search the live web

Once a page read works, try a discovery task:

Use Context.dev to find three recent official Node.js release posts.
Search nodejs.org, then read the selected pages to verify their publication
dates. Return each title, date, source URL, and a one-sentence summary.
If you cannot verify a date, say so.

This request uses the actual web-search schema:

{
  "name": "web-search",
  "arguments": {
    "query": "site:nodejs.org/en/blog/ Node.js releases",
    "numResults": 10,
    "includeDomains": ["nodejs.org"],
    "freshness": "last_month"
  }
}

numResults accepts values from 10 to 100. Ask the agent to present three verified results after searching; the tool's input does not have a limit: 3 parameter. A restricted query may return fewer results than requested.

Our live call returned Node.js release pages with url, title, description, and relevance fields. Search results were not guaranteed to contain publication dates or full page text. Read the selected URLs with web-scrape-markdown before making claims about dates or article contents.

You can request inline page scraping through markdownOptions.enabled: true. Without it, our result entries contained markdown.code: "NOT_REQUESTED". Enabling that option adds page retrieval to the search workflow; use it when you need the content of the returned results.

The freshness filter narrows discovery. It does not establish that the first three ranked links are the three newest posts on the site.

Read JavaScript-rendered pages

Context.dev's Markdown tool supports browser waits and content filters. This example reads a public JavaScript demo page and forces a fresh scrape:

{
  "name": "web-scrape-markdown",
  "arguments": {
    "url": "https://quotes.toscrape.com/js/",
    "useMainContentOnly": true,
    "includeLinks": true,
    "waitForMs": 2000,
    "timeoutMS": 60000,
    "maxAgeMs": 0
  }
}

Our live call returned the page's quote text as Markdown, the title Quotes to Scrape, and a cache miss. You can replace this URL with the public product, pricing, or documentation page you want to inspect.

These controls have distinct meanings:

waitForMs adds a fixed browser wait after the initial page load. It accepts up to 30,000 milliseconds. It does not wait for a named element to appear.
timeoutMS bounds the request. When combined with waitForMs, it must be at least waitForMs + 10000.
maxAgeMs: 0 requests a fresh scrape. If omitted, the Markdown tool permits a matching cached result up to one day old.
useMainContentOnly, includeSelectors, and excludeSelectors help select relevant content. Inspect the returned Markdown to confirm that it contains the fields you need.

The live schema also exposes an actions array for paid plans, with up to five ordered actions using do: "wait", do: "perform", or do: "scroll". Use these when the requested extraction needs a particular interaction, such as loading more visible results. Review actions that could submit a form or change external state.

See the Markdown API reference for the underlying page-retrieval controls.

Extract data with a real JSON Schema

Use web-extract when downstream code needs specific fields. Its required inputs are url and schema; the schema must be a JSON Schema object. A sample object containing strings such as "string | null" is not a JSON Schema.

The following request extracts a product from a public scraping demo. It limits the work to one page, permits missing values, and enables fact checking:

{
  "name": "web-extract",
  "arguments": {
    "url": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
    "schema": {
      "type": "object",
      "properties": {
        "name": { "type": ["string", "null"] },
        "price_text": { "type": ["string", "null"] },
        "availability": { "type": ["string", "null"] },
        "brand": { "type": ["string", "null"] }
      },
      "required": ["name", "price_text", "availability", "brand"],
      "additionalProperties": false
    },
    "instructions": "Extract only the product on this page. Preserve the displayed price and currency symbol as price_text. Use null for information the page does not state. Do not treat the shop name as the product brand.",
    "factCheck": true,
    "maxPages": 1,
    "maxDepth": 0,
    "maxAgeMs": 0,
    "timeoutMS": 120000
  }
}

Our live test returned status: "ok" and this data object:

{
  "name": "A Light in the Attic",
  "price_text": "£51.77",
  "availability": "In stock (22 available)",
  "brand": null
}

All four keys are required, but their values may be null. That keeps the object's shape predictable when a page omits a field. Keeping price_text as displayed also avoids inventing a currency code or silently changing a price's meaning.

factCheck: true instructs the extractor to ground returned values in the page and leave unsupported fields null or empty. The live schema documents false as the default, which allows reasonable inferences. Set the option explicitly when your workflow needs only stated facts.

The MCP response placed this payload in result.structuredContent; its data field held the extracted object, while url and urls_analyzed identified the sources. The result also included a text representation of the payload. A client may display either representation.

Validate the extracted object with your application schema before using it downstream. Preserve the source URLs, request identifier, and collection time alongside it. A correctly shaped object still needs the factual checks appropriate to your application. The structured extraction reference describes the underlying operation.

Expand from one page to a bounded crawl

When an answer spans several pages on one site, use web-crawl. Give the agent a starting URL and an explicit scope:

Use Context.dev's web-crawl tool to read at most five pages under
https://docs.context.dev/. Stay within that documentation site, follow
links no more than one level deep, and summarize the pages you retrieved.
Include each source URL and report any incomplete coverage.

The tool exposes maxPages, maxDepth, urlRegex, and stopAfterMs for limiting the work. It returns results synchronously and caps maxPages at 500. A page cap is an upper bound, not a promise that every page will be retrieved.

Use web-scrape-sitemap when you only need URLs. For a large asynchronous collection, use submit-batch, check progress with get-batch, and retrieve completed results with get-batch-results. Recurring checks belong in the monitor tools. Review the proposed scope before starting a batch or recurring monitor.

MCP or the direct REST API

Both interfaces give access to Context.dev operations. Choose the interface that fits the caller and the control you need.

Decision	MCP	REST API or SDK
Primary caller	A tool-enabled client or agent	Your application code
Setup	Connect the hosted server and authorize access	Configure an API client and server-side credentials
Request selection	The host or agent selects a discovered tool	Your code chooses an endpoint or SDK method
Response handling	Results enter the client's tool-use workflow	Your code validates, stores, and processes results
Typical use	Interactive research and agent-driven lookups	Application features and controlled data pipelines

MCP does not prevent a custom application from orchestrating tools explicitly. The practical benefit in Cursor and Claude is that discovery, invocation, and the conversation interface are already available. For a service with its own scheduling, storage, and retry policy, the Context.dev API quickstart is a useful starting point.

Troubleshoot the connection and tool calls

Symptom	What to check
Context.dev is missing	Confirm the configuration location, preserve valid JSON, and use the complete URL ending in `/mcp`. Refresh the client.
The server appears but tools are unavailable	Finish OAuth, enable the server or connector for the conversation, and check organization restrictions.
Authentication repeats or a call is unauthorized	Reconnect through the client's authentication controls. Inspect the error before assuming it requires an API-key change.
The agent answers without calling Context.dev	Name the provider and operation in the prompt, check that its tools are enabled, and resolve any pending approval.
Tool arguments are rejected	Compare them with the current tool schema. For example, search takes `numResults` from 10 to 100.
A rendered page is incomplete	Inspect the output, adjust content selectors or waits, and confirm the useful content is publicly accessible.
A wait request fails	Keep `timeoutMS` at least 10,000 milliseconds above `waitForMs`.
Results appear stale	Inspect `cache_metadata`; request `maxAgeMs: 0` when the operation supports it and freshness matters.
Requests hit rate limits or timeouts	Reduce concurrent work and request scope. Use bounded retries for transient failures and honor any supplied retry delay.
The account has insufficient credits	Review usage and available credits in Context.dev. Repeating the request does not replenish them.

You can check the hosted service independently:

curl --fail --silent --show-error https://mcp.context.dev/health

Our check returned status: "healthy". This checks service health; a successful authenticated tool call is still needed to verify your connection and account access.

For operation failures, the live server exposes list-logs and get-log. Find the relevant request, then inspect it by request_id. Keep that identifier when contacting support and omit credentials or sensitive page content from shared diagnostics.

Credentials and production use

Use OAuth for the interactive setup above. The production server also accepts API-key authentication through the Authorization header for private integrations. Keep those keys in a secret store, use separate credentials for separate environments, and never place credentials in a URL or committed configuration.

Treat retrieved pages as external data. A page may contain instructions aimed at an agent; that content should not authorize another tool call. Apply your host's approval controls to browser actions, persistent monitor changes, and large batch submissions.

Bound page counts, crawl depth, request duration, and retries. Track tool names, outcomes, request identifiers, source URLs, and cache age so you can distinguish a connection failure from a successful request that returned incomplete information.

The current MCP tools expose request-level browser waits and actions. They do not expose a reusable browser-session or browser-profile management tool. Workflows that need a durable login or detailed browser-state control need a separate browser-automation integration.

FAQs

Do I need Node.js or an npm package for Context.dev MCP?

The hosted Context.dev connection does not require either. Configure https://mcp.context.dev/mcp in a client that supports remote Streamable HTTP and OAuth. Follow that client's own installation requirements separately.

Do I need to generate an API key for Cursor or Claude?

The setup in this guide uses OAuth, so you sign in through your browser. API-key authentication is available for private integrations that supply an Authorization header.

Does every tool call retrieve fresh content?

Some operations can return cached data. For web-scrape-markdown, the default cache allowance is one day. Set maxAgeMs: 0 when you need a fresh scrape and inspect the returned cache metadata.

Do MCP calls use my Context.dev credits?

Yes. MCP operations use the same account credits as their corresponding API operations, as described in the MCP authentication and usage guide. A search with page scraping, a crawl, or a batch can involve more work than a single page read.

Do Cursor and Claude get the same tools?

Both connect to the hosted Context.dev server. Client settings, account access, and organization policies can affect which tools are available. The 38-tool count is the production discovery result checked on September 21, 2026; inspect the current tool list when troubleshooting or building new workflows.